COMMENT ⊗   VALID 00036 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00005 00002	Recent NEWS about E, newest news first.
C00061 00003	INDEX of commands.
C00092 00004	Abbreviations and explanation of E documentation.  Credits.
C00096 00005	General remarks.
C00104 00006	PAGE CHANGING, APPENDING, DIVIDING, COMBINING, CANCELLING: XAPPEND XTHISPAGE β<ff> XMARK XDELETE XCANCEL
C00114 00007	WINDOW and ARROW moving commands.
C00131 00008	LINE MARKING commands.
C00135 00009	LINE-EDIT commands.
C00157 00010	Attach and Copy commands: A C
C00168 00011	LINE INSERT mode.
C00179 00012	Handling very long lines.  XBREAK XJOIN
C00183 00013	Search commands: F XFIND * XEXACT F<string>P F<string>: XSSLINE XSSPAGE
C00210 00014	SUBSTITUTION commands: \
C00222 00015	FILE-SWITCHING and text transfering commands: ε λ ∃ ? XPOINTER
C00238 00016	Justification: XJFILL XJUST XJGET XSJFILL XSJUST
C00258 00017	Commands for tabular material: XTABLE XTJFILL XTJUST XTJGET XTGET
C00273 00018	MARGIN CONTROL commands: XALIGN XINDENT → ← XCENTER
C00282 00019	Other EXTENDED commands: X<cmd> Xα<cr>
C00313 00020	System commands and file SWITCHES.
C00341 00021	Using E from a non-display (TTY).  XTYPE XNUMBERS XHEADER XTRAILER XCONTROL XMETACONTROL
C00357 00022	PARENTHESIS finding/matching commands: ( ) XLPAREN XRPAREN ↔ XPAREN XPINFO
C00369 00023	Swapping To and From E via RPG startups: XRSYS XRUN XGORPG XDRD XTV
C00376 00024	Message and paragraph handling commands: ∂<cmd> 0∂ !<cmd> 0!
C00390 00025	Macros: XDEFINE Z Y ≡ ∩ ∪ ⊂ ⊃ $ % ~ _ XCASE XRESUME XABORT # XSTOPALL XSTOPONE XSTOPZERO XSTOPHOW XSILENT XRAPID
C00426 00026	Numeric Macros and Readonly Variables: XSET XARGUMENT XMULTIPLY XDIVIDE XREMAINDER XADD XSUBTRACT XMINIMUM XMAXIMUM XIFLT XIFLE XIFGE XIFGT XIFEQ XIFNE XCHARACTER
C00450 00027	Macros and Command Files: XEXECUTE PUTDEFS XCOMMENT XATTACH XREDEFINE
C00459 00028	Debugging macros: XSAY XAUTOSTEP XSTEP &
C00466 00029	BOOK MODE (/B) and the BOOK command
C00473 00030	E files extended by other programs.  XUPDATE -XUPDATE
C00477 00031	Filenames, numeric extensions, and filehacks
C00484 00032	Generating a new directory line: XNDFAIL XNDSAIL XNDBBOARD
C00493 00033	Altering the use of the display screen: XTOPSET XBOTSET XATTSET XHEIGHT
C00501 00034	αβS. N,O,H: Line, Page & File stacks. XHOME XBACKGO XZFILES XZPAGES XZLINES
C00522 00035	Undeleting lines of text: XUNDELETE
C00527 00036	Lisp code indenting commands: α/ αβ/ XLISPSYNTAX
C00537 ENDMK
C⊗;
Recent NEWS about E, newest news first.
  Index of E commands is on p. 3.
  A history of E changes is in E.UPD[UP,DOC].

∂3 Mar 79 -- Omitted second arg in two-arg filename switches defaults to zero.

 This allows you to type, for example, ET \B/11M/22M/33M,\G/4M<cr> to put
 line marks at the beginnings of pages 11, 22 and 33 in the BBOARD file,
 and page 4 in the GRIPES file (in case the CKSUM program just told you
 that those pages had changed, for example).  Then you can use the αM
 command to get to the indicated pages.  In this case, the second arg of
 each /M switch is omitted (the second arg is the line number), but is
 taken to be zero; formerly, an omitted second arg got a random value.
 (Remember that you cannot add marks to a file that already appears in
 your file stack, e.g., from a previous edit, since that file's old line
 marks are restored.)

∂20 Feb 79 -- New listing of commands at beginning of each page of E.ALS.

 In the main part of E.ALS, every page that describes one or more
 particular commands now begins with a list of all commands described on
 that page.  This list is a duplication of all the one-line entries from
 the index on page 3 that refer to the given page.  Thus the beginnings of
 every page of E.ALS along with the directory together form a "functional
 index" of E commands.

∂9 Feb 79 -- New search limiting capability, readonly variables, and more.

 The commands ⊗XSSLINE and ⊗XSSPAGE set or report the limit line number
 and limit page number for searches and substitutions.  These commands can
 be used to keep searches and substitutions from going beyond a given
 incore line or a given page; search limiting affects these commands:

	⊗F ⊗XFIND ⊗* ⊗\ ⊗( ⊗) ⊗XLPAREN ⊗XRPAREN

 The ⊗#⊗XSSLINE command sets the search-limiting incore LINE number to the
 given argument (#), and similarly ⊗#⊗XSSPAGE sets the search-limiting
 PAGE number to the argument (#).  In both cases, if the argument is
 relative (⊗+ or ⊗- used), then the limit is set by the command at the
 given distance (lines or pages) from the current place (line or page)
 (but is fixed once set by the command; that is, it is not permanently
 relative to the arrow's position).  If the argument is omitted entirely,
 then the corresponding type of search limiting is disabled.  A zero
 argument will cause E simply to report the given search-limit.

 Search-limiting stops any search (except a directory search, see below)
 that encounters the given limit line or the beginning of the given limit
 page; for instance, ⊗5⊗XSSPAGE will stop any search that encounters the
 beginning of page 5, so page 5 will NOT be searched (but a search started
 already on page 5 won't be limited).  As another example, ⊗+⊗XSSLINE will
 limit any search to the current line, since it will stop any search upon
 reaching the following line.  The search-limiting LINE number applies
 only to incore text and is cleared when you flush all incore text (e.g.,
 by going to another page or by doing an ⊗XCANCEL command).  The
 search-limiting PAGE number applies both to incore pagemarks and to
 not-in-core pages (the latter reached only by the ⊗XFIND, ⊗XLPAREN, and
 ⊗XRPAREN commands); the limiting page number is cleared when you change
 files.  Search limiting is always completely disabled during directory
 searches (e.g., ⊗F...⊗P and ⊗F...⊗:).

 Any incore limit line number set up is adjusted for text insertion and
 deletion, to preserve the point in the text at which searches will stop.
 Currently, however, any limit page number is NOT adjusted for page
 insertion/deletion.  The two new readonly variables SSLINE. and SSPAGE.
 are available for macros to find out the current search limits; a
 negative or zero value means the corresponding type of search limiting is
 disabled.  Note that the limit LINE number is counted from the beginning
 of ALL incore lines, not just relative to the current page if you have
 more than one page in core.


 Three new readonly variables have been added for finding out how many
 occurrences of the current search string were
	(1) searched for:    NFIND.
	(2) found:	     NFOUND.
	(3) substituted for: NSUBST.
 in the last search (or substitution) command.  If that search included at
 least one successful substitution, then NFOUND. will be zero and NSUBST.
 will be positive.  If the last search did not do (but maybe tried and
 failed) any substitutions, then NSUBST. will be zero and NFOUND. will be
 the number of occurrences found (possibly zero).  NFIND. contains the
 requested number of search or substitution repeats.  The only slightly
 obscure case is a command like ⊗4⊗F...⊗\...αβ9<cr>, which asks to do 9
 substitutions starting with the 4th occurrence; if less than 4
 occurrences are found, then NFIND. will be 4, NFOUND. will be less than
 4, and NSUBST. will be zero, but if 4 or more occurrences are found, then
 NFIND. will be 9 (NOT 4), NFOUND. will be zero (meaning we did some
 substitutions), and NSUBST. will be the number of substitutions done.


 The filehack \NEWS has been added to access the new NYT NewsSummary file
 NEWS.TXT[2,2].  The NYT NewsSummary is similar to the AP News Digest.

 The αXSAY command no longer puts a space at the end of the text it types
 out.  You can of course put a space at the end of the αXSAY command line.

 The command ⊗\ no longer accidentally ignores the first #-1 occurrences
 if you had just given a ⊗#⊗* command.  Also, ⊗#⊗F...⊗\...⊗∞<cr> no longer
 substitutes only for every #th occurrence, but does every occurrence
 starting with the #th, as previously advertised.

 E now correctly detects an old E directory in a file that has been edited
 with SOS and which now has line numbers.  You get a chance to flush the
 directory when you are reformatting with E (formerly E treated the old
 directory as plain text).

 ⊗XEXECUTE and ⊗XPUTDEFS now set the new default filename for these
 commands only upon success in reading or writing the given file.

 Stepping macros now properly aborts N levels (upon error or ⊗#⊗XABORT
 command) BEFORE finishing the stepping.  Makes macro stepping work on fancy
 macros.

 The arrow line number at the bottom is now properly updated after a ⊗*
 command, and the screen erasing is now done correctly upon ⊗XBOTSET.

 The ⊗XNDBBOARD command has really been fixed this time to update the
 display of the old first line on a DM if ∂ became >.

∂29 Jan 79 -- Minor fixes.

 The ⊗XNDFAIL command now recognizes symbols up to 20 chars in length, but
   symbols can contain only:  letters, digits, and any of ".%_$".
 Bug fix to handling of the characters ≤ and ≥ in justification.
 Bug fix to <vt> in attach mode to correctly position attach buffer at
   bottom of screen.
 The ⊗0⊗J command in attach mode centers among non-attached text on screen.

∂5 Jan 79 -- Attempt to minimize frequency of display lossage on DDs.

 To reduce the frequency of half-field DD display trouble, a slight
 compromise was needed for DD displaying.  Namely, if a line has 9 or 10
 tabs in the first 80 columns, then the characters in columns 81 to 84 may
 not get displayed by E (they will of course appear in the line editor, as
 do characters beyond column 84).  In particular, with 9 tabs in the first
 80 columns, characters in columns 83 and 84 will not be displayed, and
 with 10 tabs in the first 80 columns, characters in columns 81 through 84
 will not be displayed.  This change seems to have cut the frequency of DD
 display trouble by a factor of 10 (a system mod has lessened the problem
 further still).

∂4 Jan 79 -- Fix to ⊗/ command when given in insert mode for top window line.

∂1 Jan 79 -- Three minor fixes.

 Bug fix to ⊗XTJxxx and ⊗XTABLE commands to avoid screwing up when
   in attach mode.
 Bug fix to ⊗XNDBBOARD command on DMs to properly update display of
   old first line if "∂" changed to ">".
 Good extension .MFT changed to .MF for Metafont.

∂11 Dec 78 -- Fix to avoid runaway detached E jobs.

∂7 Dec 78 -- New improved vertical movement commands: α; αβ; α: αβ:

 The four vertical movement commands α; αβ; α: αβ: have been slightly
 changed to improve their usefulness.  It is now possible to move up and
 down with these commands, passing through short (or empty) lines and
 through tabs without losing your "column of interest".  The double-bucky
 commands αβ; and αβ: now set the "column of interest" to the column where
 the command is given (if you are in the line editor).  These double-bucky
 commands then move to the new line and try to position you to the new
 column of interest.  The CONTROL-only commands α; and α: merely move
 you to the new line and position you at the old (and unchanged) column of
 interest.  Thus, when you are moving up or down on a page, you should use
 the αβ; or αβ: version THE FIRST TIME, in order to set the column of
 interest, and thereafter use only the α; and a: commands, until you want
 to change your column of interest.  Note:  The αβ; and αβ: commands do
 not set a new column of interest except when given from within the line
 editor.

 The current "column of interest" for the ⊗; and ⊗: commands can be
 accessed in the Readonly Variable "COLINT.".

 Also, ⊗XPOINTER recognizes filenames preceded by "@".  

∂1 Dec 78 -- Minor fix to macro stepping routines.

∂27 Nov 78 -- ⊗XSET can copy whole macros.

 The command ⊗XSET <macro1>←<macro2> now copies the whole of <macro2>'s
 definition into the new defintion of <macro1> (formerly this only copied
 the numeric value of the second macro into the first).  Also, the second
 macro name can now be blank (e.g., ⊗XSET MAC←<cr>); thus even the
 definition of the blank-named macro can be copied (in case you forgot to
 enter a non-blank name when you defined the macro).

 Also, the extension .TFX has been added to E's list of bad filename
 extensions, and .TFD has been added to E's good extension list.

∂22 Nov 78 -- Nine new single character macro calling cmds (top digits).

 The nine new single-character commands ⊗≡ ⊗∩ ⊗∪ ⊗⊂ ⊗⊃ ⊗$ ⊗% ⊗~ ⊗_ (all
 found on the top of the digit keys on SU-AI keyboards) can now be defined
 as macros.  The names of these macros (for use in macro-handling commands
 like ⊗XDEFINE <macro name>) are the same as the command names (less the
 CONTROL/META bits).  Thus, ⊗XDEFINE $<cr> lets you define the ⊗$ command
 as a macro, and ⊗Z$<cr> executes the $ macro just like the ⊗$ command
 does.  Of course, ⊗0⊗$ will type out the definition of the $ macro (if
 any), and ⊗#⊗$ will call the $ macro with a repeat arg of #.

 There is one special feature of these special single-character macros:
 namely, the ⊗Y command will NEVER execute any of these macros, since
 each of them has its own single-character command.  That is, defining
 (or calling with the ⊗Z command) any of these macros does not change
 the default macro that ⊗Y will execute (as would be the case for a
 normal macro definition or call from the top level).

∂19 Nov 78 -- ⊗XRAPID mode bug fixed and ⊗0⊗XRAPID now reports mode.

 A bug in the line editor simulator (⊗XRAPID mode) has been fixed.  The
 bug occurred (and was usually fatal) when a macro generated a line editor
 activator when the cursor pointed to a tab in the (simulated) line
 editor.  Very soon now, ⊗XRAPID mode will become the default.

 Also, ⊗0⊗XRAPID now reports whether the line editor simulator (for
 macros) is enabled (⊗XRAPID mode) or disabled (⊗-⊗XRAPID mode).

 Finally, the ⊗XWRITTEN command now works even right after you have
 reformatted a file (w/ or w/o a directory).

∂17 Nov 78 -- ⊗XNDBBOARD command for updating directory line in \BBOARD file.

 The new command ⊗XNDBBOARD (New Directory-line for \BBOARD) generates a
 new directory line for the current page from the old directory line,
 assuming it is in the MAIL message header format or the ⊗XNDBBOARD
 format.  These two formats are distinguished by whether the first space
 in the line is followed by a second space.  If so, then is MAIL format
 and this command flushes the original time from the header and inserts
 the current date and the current user's programmer name after the
 original programmer name.  If the old directory line was already in
 ⊗XNDBBOARD format, then the update date is replaced by the current date
 and the updating programmer name is replaced with the current user's
 programmer name.  No guarantees are made about what this command will do
 with a page whose first line is in any other format.  Note that this
 command does not delete the old header line (the user should do that
 himself), but it does replace any initial partial-sign (∂) in that line
 with a greater-than sign (>) to make sure the ⊗∂ command will still work
 on the whole message.

 Also, .MFT (METAFONT) has been added to E's list of good extensions.

∂15 Nov 78 -- E now handles pages with more than 2↑18 chars.

 The page size limit is now about 2↑27 characters, but the core size
 limit of 256P for the lower segment is the real limiting factor.

∂10 Nov 78 -- Leading empty lines omitted in text given to MAIL.

 The ⊗XMAIL, ⊗XSEND and ⊗XREMIND commands now omit any leading empty lines
 in the range of lines being given to the MAIL program.  This allows you
 to, for instance, enter a one paragraph message at the end of a page
 (preceded by a empty line) and then, while pointing anywhere within the
 paragraph (including the end of the page), mail the paragraph with
 α!⊗XMAIL, which will conveniently ignore the empty line that starts the
 paragraph (as defined by the α! command).

∂2 Nov 78 -- Two minor bug fixes.

 ⊗∂<plain char> now works again.
 ⊗XCHARACTER and ⊗XBREAK now evaluate numeric macros and readonly
   variables properly.

∂12 Oct 78 -- Macro stepping and autostepping; errors that always STOPALL; more.

NEW READONLY VARIABLES FOR JUSTIFICATION MARGINS

The following readonly variables have been added for examining the
justification margins.  Those with the initial letter T are the margins
for the ⊗X TJxxx commands; those without the T are for the normal ⊗X Jxxx
commands.

  CMAR  TCMAR	Crown line indent (first line of paragraph).
  LMAR  TLMAR	Left margin (amount of indentation for body of paragraph).
  RMAR  TRMAR	Right margin; last column that will be used for text.
  BNUM  TBNUM	Blank line count -- number of blank lines put between paragraphs.
  CMARO TCMARO	Old crown indent; a line with CMARO indentation is taken as
  LMARO TLMARO	  starting a new paragraph, unless CMARO = LMARO.


GENERATING CHARACTERS FROM NUMERIC VALUES

The command ⊗#⊗XCHARACTER <numeric code for <character>> <cr> has the same
effect as typing ⊗#<character>.  Note that any repeat arg for the extended
command is passed to the indicated character, which should be between '001
and '777 inclusive (and the low-order 7 bits must not be zero); thus the
CONTROL ('200) and META ('400) bits can be included in the character.  The
⊗XCHARACTER command is primarily for macros that want to generate text
and/or commands from numeric calculations, but it can also be used to type
any command character(s) that your keyboard cannot otherwise input (e.g.,
if some key is broken).  (Note that ⊗XCHARACTER isn't legal in the middle
of another command, so you can't always avoid typing a certain character.)

The character's numeric code can be entered as a constant (decimal, unless
preceded by right single quote (') which makes it octal); or it can be
entered as the name of a numeric macro or readonly variable, in which case
the value of the named entity will be used.  Thus, the command
αβ2⊗XCHARACTER ASCII.<cr> will cause the current character to be typed
twice.


SPECIFYING FOLLOWING NUMERIC ARGUMENTS TO EXTENDED COMMANDS WITH
    NUMERIC MACROS, READONLY VARIABLES, AND OCTAL CONSTANTS

Certain extended commands that normally take one or more decimal numbers
following the command name will now accept the name of a numeric macro
or readonly variable in place of the decimal constant.  For instance,
⊗XBREAK RMAR.<cr> will break the current line at the column that is the
right margin for the normal justification commands.

The same extended commands (see list below) will also accept an octal
constant instead of decimal.  Octal is indicated by preceding the number
with a right single quote ('); for instance, ⊗XBREAK '177<cr>.

The commands that currently accept these alternative forms for a number
following the command name are:
	⊗XBREAK
	⊗XCHARACTER
Eventually almost all extended commands will accept these alternative forms.


LINE-EDITOR-ENTERING COMMANDS GIVEN FROM THE LINE EDITOR

E commands that normally cause the current line to be edited with the line
editor are now legal even when given from within the line editor itself.
Most of these commands are usually handled directly by the line editor,
without E ever seeing them.  But if such a command is generated in a way
that causes activation of the line editor, for instance, by preceded it
with a repeat argument using both CONTROL and META, then E now figures out
how to carry out the command, usually including reloading the line editor
with the resultant text.  Thus the command αβ8G will type eight G's into
the line editor, and αβ8βH will insert 8 H's.


ERROR MESSAGES FOR COMMANDS ILLEGAL FROM THE LINE EDITOR

The (in)famous general error message -- ?HUH? -- that E formerly typed
whenever a bad command was given from the line editor has been replaced with
specific error messages that attempt to tell you what was wrong, including
the actual bad command itself.  If the command is always illegal from
the line editor, or if it cannot be carried out from the line editor
in the current situation, then the error message will say something like
"Command illegal from line editor here" (plus the command itself).
This is particularly important when debugging a macro, because this
particular error ALWAYS stops all macros in progress, regardless of the
current STOPxxx setting.


CERTAIN ERRORS ALWAYS TREATED AS IF STOPALL MODE IN EFFECT FOR MACROS

Certain errors that E detects now always cause stopping of all macros
in progress, regardless of the current STOPxxx setting.  These errors
are never expected to occur deliberately inside macros, and so they
stop all macro execution as an aid to macro debugging.  The current
such "fatal" errors for macro execution are:

	Unrecognized command character
	Ambiguous (extended) command
	Unknown (extended) command
	Syntax error in extended command line
	Can't exit while expanding a macro
	Command illegal from line editor here
	Macro pushdown list overflow
	Macro text for line editor is too long
	(Syntax error in LISPSYNTAX command)
	Cannot execute a readonly variable


DEBUGGING MACROS BY STEPPING

Some facilities are provided to allow the user to debug even complicated E
macros.  With these facilities, it is possible to step through macro
expansion (possibly pausing a little at each step) while having the
display updated to see the result of each step or of selected steps in the
macro expansion.  While E is stepping a macro, it will type out the
characters of each step just before that step is carried out.  Whenever E
is pausing at a certain macro step, ESC I will, as usual, immediately
abort all macros in progress.  When a macro step pause occurs from the
line editor, the display of the line editor text will be done by E and a
cursor will be displayed at the proper character within the line.  This
pausing in the "line editor" can be identified on DDs and IIIs by the
slightly wider cursor and on DMs by the "line editor" text NOT being
displayed in BOLD; this is to avoid fooling you into thinking that the
macro has ENDED in the line editor.

A macro step generally involves one complete E command -- for instance not
just ⊗X but a whole extended command line when ⊗X is encountered.
However, any sequence of all line editor commands given from WITHIN the
line editor, none of which would activate the line editor, is treated as a
single step along with the first (complete) command that does activate the
line editor.  Such a sequence does not include the command that made E
enter the line editor; that command is taken as a separate step.

The ⊗#⊗V command causes E to update the display immediately and then pause
# seconds.  If the ⊗# is omitted, then E will merely update the display
without pausing.  This is an old feature, but the display updating now
works properly even if the ⊗V is given from the line editor.

The ⊗#⊗XAUTOSTEP command enables a mode in which EVERY macro called is
executed by pausing # seconds after each step.  See the second paragraph
above for what constitutes a single step.  The command ⊗-⊗XAUTOSTEP
disables this mode of automatic stepping of macros, and ⊗0⊗XAUTOSTEP
reports the status of this mode.  The readonly variable STEP. contains the
number of seconds per pause, or a zero or negative number if autostepping
is disabled.

For manually stepping macros, there are two commands available:
	⊗#⊗XSTEP <optional macro name> <cr>
	⊗#⊗&
The extended command version optionally takes a macro name following the
command name; if a macro name is given (the blank name is not permitted),
then this command will call that macro and execute # steps before
stopping (a repeat arg of 1 will be used for this macro call).  If no
macro name is given with ⊗XSTEP, or if the command ⊗& is used, then macro
execution is RESUMED (where it previous left off) for # steps (where # is
the argument to the command); thus when macro execution has been
interrupted, you can single step the remainder of the macro(s) with the
⊗& command.  Another difference between ⊗& and ⊗XSTEP is that the latter
will cause an explicit message to be typed out when the given number of
steps have been executed -- "Stepping done, in <macro name>"; this
message is always suppressed for the ⊗& command and by Terse mode with
the ⊗XSTEP command.  Note that if you give one of the stepping commands
while in AUTOSTEP mode, E will still pause after each step, but it will
quit stepping when the stepping count has been exhausted.


LINE EDITOR DISPLAY UPDATED WHILE TYPING REMAINDER OF COMMAND

When you activate the line editor with part of a command that might end up
returning you to the line editor without having accepted the edited
version of the line, E will redraw the line editor text while awaiting the
rest of the command.  This currently applies to the following partial
commands: ⊗X ⊗Z.  Also drawn will be a special cursor to indicate where in
the line you are giving the command from.  (The cursor is the same one
you'll see when stepping macros -- wider than the normal ones on DDs and
IIIs.)  However, if the line is longer than the screen width, the wrapped
around part of the line will not be displayed, nor will the cursor if it
is in that part.


OTHER MISCELLANEOUS FIXES:

⊗XNDFAIL has been fixed not to make entries for "zero-length" labels.
Two line editor simulator (⊗XRAPID) bugs fixed: overtyping and α<tab>.
  Soon ⊗XRAPID will become the default.
The macro expander's line editor handler now understands that αD and αI
  activate immediately on an empty line.
Directory errors encountered on reading in a page (missing pagemark at
  beginning of page, or ending pagemark not at proper record) are fatal
  unless in /R mode.  You can no longer continue after these errors unless
  you are in /R mode, and in any case you will not be allowed to change
  the file.

∂30 Sept 78 -- More ⊗XRAPID macro operation when using line editor.  ⊗XBLOAT cmd.

NEW MACRO FEATURES:

The new (temporary!) command ⊗XRAPID makes macros try to use E's new line
editor simulator, which can reduce macro execution times by as much as a
factor of 10.  (Macros that do not use the line editor are not affected by
the creation of the simulator.)  The line editor simulator is fairly
primitive in that it can only do a limited number of line editor
operations, but when the simulator cannot handle a line editor command,
the real line editor is used instead.  Thus macros will work the same with
or without the simulator, but execution time will be reduced if the
simulator can handle all the line editor operations in a given sequence.
Since the simulator avoids doing any UUOs that invoke the real line
editor, line editor simulation is up to 10 times as fast as real line
editor use.  It is possible that there might be some undiscovered bug(s)
in the simulator -- hence the ⊗XRAPID command must be given to enable use
of the simulator.  However, when the simulator has shown itself to be bug
free (which it may already be), it will become permanently enabled and the
⊗XRAPID command will go away.  For now, the ⊗-⊗XRAPID command disables use
of the simulator.

The ⊗XSET command has been extended to allow a simple assignment statement
that copies one numeric macro value into another macro.  Thus
	⊗XSET FOO ← BAZ <cr>
sets FOO to the numeric value of BAZ.  (Equals-sign (=) can be used in
place of the left-arrow.)  Neither the first nor the second macro name can
be blank when this form of ⊗XSET is used.  The second name can be that of a
readonly variable (ending with ".").  This command is needed to copy
large-valued numeric macros, since ⊗XARGUMENT BAZ<cr>⊗XSET FOO<cr> will
truncate BAZ's absolute numeric value to 2↑17 - 8, which is the maximum
legal repeat argument.  Eventually, ⊗XSET FOO = <algebraic expression> <cr>
may be implemented.  If only one macro name appears in the ⊗XSET command,
and if no left-arrow or equals-sign appears, then the named macro is set to
the value of the repeat argument, as before.  The ⊗XSET command may be
aborted if E can't figure out what you wanted.

The new ⊗XSAY command simply types out (1) the text on the command line
after "SAY " and then (2) the decimal repeat arg, if any.  The typeout is
ended with a <crlf> if αβX is used or with a <space> if αX is used in the
command.  This command can be useful inside macros to report the status of
the macro execution, but it works outside of macros as well.

In the ⊗XREDEFINE and ⊗XEXECUTE commands, two escape sequences have been
added to allow comments to be embedded in the text of commands (e.g., in
command files).  The first form makes the rest of the current line be
treated as comments, and the second form allows comments to occur in
the middle of a line.  These escape sequences are more useful for comments
in macro definitions than the ⊗XCOMMENT command because the latter causes
the comment line actually to become part of the macro definition.

	⊗;	Ignore text from here to end of line (to next CR, LF, or FF).
	⊗⊂	(Left horseshoe) Ignore from here to first right-horseshoe (⊃).


MISC NEW FEATURES:

⊗#⊗XBLOAT writes out the current page with at least # records of nulls to
provide space for text to added later.  This command is useful if you are
preparing to add a lot of text to a page and you don't want E to have to
ripple every time you need one more record for the page's text.  If you
have the last page of the file in core, then this command will not write
out any extra records of nulls since they aren't needed to avoid rippling.
If you have more than one page in core, the extra space is allocated to
the last incore page.  This command disables autoburping if # exceeds the
current autoburp threshold, in order to avoid having the new bloatedness
autoburped away in the near future.

The ⊗XCA and ⊗XAL commands are the same as ⊗XCANCEL and ⊗XALIAS,
respectively, to allow abbreviation of these commands to two letters.

The commands αD and αI as search-string-ending commands are now once again
carried out at the beginning of the found string instead of at the
beginning of the line the string starts on.

∂27 Sept 78 -- New ⊗XCASE command calls Nth macro named in command line.

The following command can be used to select and call one macro from a
list.  In this case the repeat argument to the command determines which of
several possible macros is to be called.  This command is normally used
inside a macro that might want to call some other macro(s).

	⊗#⊗XCASE <macro name> <macro name> ... <macro name><cr>

This command executes the #th macro in the list of macro names, where the
counting of # starts at zero (0); the selected macro is executed with a
repeat arg of 1.  For instance, ⊗2⊗XCASE A B C D<cr> will execute macro C.
The macro names should be separated with spaces.  No macro name in the
middle can be omitted, and the null (blank) macro name cannot be used
here; however, any non-blank names can be supplied, since E does not check
that all such names represent currently defined macros.  If the repeat arg
given to ⊗XCASE is negative, then the command will be aborted.  Since the
extended command line is buffered in E, and since the buffer has a fixed
size, there is an effective limit to the number of macro names that can be
listed in the command line; the current maximum command line length is
about 119 characters -- characters beyond that are ignored.  An error will
occur if there are not enough macro names in the command for the given
repeat arg.


Because of the new ⊗XCASE command, the old ⊗XCANCEL command can no longer
be abbreviated ⊗XCA<cr>.

Also:

 Bug fix to ⊗XREDEFINE when macro text from page starts with a tab.
 Macro pushdown list size has been increased from 24 to 48 (decimal).
 Macro pushdown overflow stops all macros but now preserves stack for ⊗XRESUME.
 ⊗-⊗#⊗XUNDELETE info message suppressed in terse mode.
 Bug fix to restore autoburping.

∂26 Sept 78 -- ⊗-⊗XECHO turns off echoing of text from line editor.

⊗-⊗XECHO turns off the echoing of text edited in the line editor (displays
only).  In this mode, however, the activator of such edited text is typed
out so that you can tell what it is (although this typeout will occur late
since it is done by E, not the system).  The command ⊗XECHO restores the
normal mode in which all input is echoed (except for that generated during
macro expansion).  ⊗0⊗XECHO reports the state of echoing.

Bug fix to ⊗XARGUMENT when getting readonly values from line editor.

∂ *** A HISTORY OF OLDER E CHANGES IS CONTAINED IN:  E.UPD[UP,DOC]  ***
      All information in E.UPD has been merged into this manual.

INDEX of commands.

Read α as CONTROL, β as META, and ⊗ as either CONTROL or both CONTROL and META.

Modes:	N=Normal, E=line-Edit, A=Attach
	I=command explicitly affects LINE INSERT mode
	L=command is a Line editor command,
	S=command takes arg from Search distance.
# stands for any decimal number.
    Note that when a repeat argument is given from the line editor, the
    form αβ# must be used instead of α#, since the latter would be taken
    as a line editor repeat count instead of an E-command repeat arg.

Page  Modes	Command		Meaning

  7   N,A	<form>	Go forward one window among incore text
  7   N,A	⊗0<form> Go forward a half window among incore text
  7   N,A	⊗#<form> Go forward # windows among incore text
  7   N,A	⊗<form>	Go forward one window, changing pages if necessary
  9   E,L	α<form>	Move cursor to beginning of line
  6   N		β<form>	Insert an incore pagemark
  7   N,A	<vt>	Go back one window among incore text
  7   N,A	⊗0<vt>	Go back a half window among incore text
  7   N,A	⊗#<vt>	Go back # windows among incore text
  7   N,A	⊗<vt>	Go back a window, changing pages if necessary
  7   N,A	β<vt>	Go back a window, changing pages if necessary
  7   N,A	<cr>	Move arrow to next line
  9   E		<cr>	Close line and move arrow to next line
  9   E		α<cr>	Leave LINE-EDIT mode, stay on same line
 11   I		α<cr>	Leave LINE INSERT mode, stay on same line
 13   N		α<cr>	Position cursor at found string (after find)
  9   N		β<cr>	Insert <cr>
  9   E		β<cr>	Close line and insert <cr>
  9   I		β<cr>	Insert <cr> but don't leave LINE INSERT mode
 11   N,I	αβ<cr>	Enter LINE INSERT mode and insert a blank line
 11   E,I	αβ<cr>	Enter LINE INSERT mode breaking current line at cursor
 11   N,E	⊗#αβ<cr> Insert # blank lines
  7   N,A	<bs>	Move arrow up a line
  9   E,L	<bs>	Move cursor left a char, deleting if at end of line
  9   E,L	α<bs>	Move cursor to left (never deleting char)
  7   N,A	β<bs>	Move arrow up a line
  9   E,L	β<bs>	Delete char to left
  7   N,A	⊗<bs>	Move arrow up a line (see also ⊗U cmd)
  9   E,L	αβ<bs>	Repeatedly move cursor to left (as long as held down)
  9   N,E,L	α<tab>	Go to end of current line
 11   N,E,I	αβ<tab>	Go to end of current line and enter line insert mode
      N,A	<alt>	Abort command
  9   E		<alt>	Restore line to original condition
 11   I		<alt>	Close line, leave LINE INSERT mode, delete line if empty
 13		<ESC>I	Terminate multi-page FIND
 14		<ESC>I	Terminate multiple substitution
 25		<ESC>I	Terminate macro expansion
  7		<ESC>I	Terminate wait on delayed ⊗V command
 10   N,A,E,S	⊗A	Attach 1 line
 10   N,A,E,S	⊗#⊗A	Attach # lines
 10   N,A,E	⊗+⊗A	Attach 1 more line
 10   A		⊗-⊗A	Attach 1 less line
 10   N,E	⊗-⊗A	Attach line just above current line
  7   N,A	⊗B	Glitch screen up from Bottom
  7   E		αβB	Glitch screen up from Bottom
  9   E,L	αB	Move backwards in line editor to next char typed
 10   N,A,E,S	⊗#⊗C	Copy # lines into attach buffer
 10   N,E	⊗-⊗C	Copy line just above current line
 10   A		⊗+⊗C	Copy one more line
 10   A		⊗-⊗C	Copy one less line (i.e., kill last line in attach buffer)
  9   E,L	αD	Delete char (if at end of line, delete CRLF)
  7   N,S	αβD	Delete line
  7   N,S	⊗#αβD	Delete # lines
  7   N,S	⊗-αβD	Delete previous line
  7   N,S	⊗-⊗#αβD Delete # previous lines
  7   N		⊗E	Exit
 10   A		⊗E	Leave ATTACH mode by putting down all attached lines
 13   N,A,E	αF	Find string (delimiters not required)
 13   N,A,E	αβF	Find delimited string
		⊗G	Unused
 34   N,A	αH	Go to previous file in file stack (Home)
 34   N,A	αβH	Go to Nth previous file, where N is current default arg
 34   N,A	⊗0αH	Type out file stack
 34   N,A	⊗0αβH	Type out default arg for αβH command
 34   N,A	⊗#αH	Go to #th previous file
 34   N,A	⊗#αβH	Go to #th previous file and set default arg to #
 34   N,A	⊗-⊗#⊗H	Go to #th previous file and pop # files off top of stack
 34   N,A	⊗+⊗#⊗H	Re-push # files back onto top of stack and go to new top
  9   N,E,L	αI	Enter Insert mode (at end of line, enter LINE INSERT mode)
 11   N,I	αβI	Enter LINE INSERT mode and insert a blank line
 11   E,I	αβI	Enter LINE INSERT mode in current line (new line if at end)
  7   N,A,E	⊗J	Jump the arrow line to the top of the screen
  7   N		⊗-⊗J	Jump the arrow line to the bottom of the screen
  7   N,A,E	⊗0⊗J	Jump the arrow line to the center of the screen
  7   N		⊗#⊗J	Jump the arrow line up # lines
  7   N		⊗-⊗#⊗J	Jump the arrow line down # lines
  9   N,E,L	αK	Kill characters forward up to next char typed
 10   A		αβK	Kill all attached lines
 10   A		⊗#αβK	Kill # lines at front of attach buffer
  9   E,L	αL	Kill characters backward up to next char typed
  7   N,A	αL	Go to first line of current page
  7   N,A,E	αβL	Go to first line of incore text
  7   N,A,E	⊗#αL	Go to Line # of current page
  7   N,A,E	⊗#αβL	Go to Line # of all incore text
  8   N,A	αM	Go forward to next Mark
  8   N,A	⊗-αM	Go backward to previous Mark
  8   N,A	⊗#αM	Go forward # Marks
  8   N,A	⊗-⊗#αM	Go backward # Marks
  8   N,A	αβM	Place a Mark on current line
  8   N,A	⊗-αβM	Clear Mark on current line
  8   N,A	⊗0⊗M	Report the number of Marks in current file
 34   N,A	αN	Go to previous line in line stack
 34   N,A	αβN	Go to Nth previous line, where N is current default arg
 34   N,A	⊗0αN	Type out line stack
 34   N,A	⊗0αβN	Type out default arg for αβN command
 34   N,A	⊗#αN	Go to #th previous line
 34   N,A	⊗#αβN	Go to #th previous line and set default arg to #
 34   N,A	⊗-⊗#⊗N	Go to #th previous line and pop # lines off top of stack
 34   N,A	⊗+⊗#⊗N	Re-push # lines back onto top of stack and go to new top
 34   N,A	αO	Go to previous page in page stack
 34   N,A	αβO	Go to Nth previous page, where N is current default arg
 34   N,A	⊗0αO	Type out page stack
 34   N,A	⊗0αβO	Type out default arg for αβO command
 34   N,A	⊗#αO	Go to #th previous page
 34   N,A	⊗#αβO	Go to #th previous page and set default arg to #
 34   N,A	⊗-⊗#⊗O	Go to #th previous page and pop # pages off top of stack
 34   N,A	⊗+⊗#⊗O	Re-push # pages back onto top of stack and go to new top
  6   N,A	αP	Go to next Page
  6   N,A	αβP	Go to next Page that is not in core
  6   N,A	⊗-αP	Go to previous Page
  6   N,A	⊗-αβP	Go to previous Page that is not in core
  6   N,A	⊗#αP	Go to Page #
  6   N,A	⊗#αβP	Go to Page #, retaining only it in core
  9   N,E	⊗Q	Copy line above, and enter copy in line-edit mode
  9   N,E,L	αR	Repeat line editor αS or αK or αB or αL cmd
 10   A		αβR	Replace attached lines (put them back where picked up)
  9   N,E,L	αS	Skip to next char typed
 34   N,E	αβS	Re-edit the last line edited, at column were activated it
  7   N,A	⊗T	Glitch screen down from Top
  7   E		αβT	Glitch screen down from Top
  9   E,L	αT	Transpose the previous two chars in the line editor
  7   N,A,E	⊗U	Move arrow Up a line (recommended cmd for non-displays)
  7   N,A,E	αV	Redraw screen (without clearing)
  7   N,A,E	αβV	Clear and then redraw screen
  7   N,A,E	⊗#⊗V	Redraw screen and then wait # seconds; ESC I ends wait
  7   N,A,E	⊗W	Go forward one window among incore text
  7   N,A,E	⊗0⊗W	Go forward a half window among incore text
  7   N,A,E	⊗#⊗W	Go forward # windows among incore text
 19   N,A,E	⊗X	Enter eXtended command next
 19   N,A,E	⊗Xα<cr> Load line editor with previous extended cmd line to retry
 25   N,A,E	⊗Y	Call current macro
 25   N,A,E	⊗Z	Call a named macro
 25   N,A,E	⊗#	(Actually the "#" char) Pass macro call arg to next cmd
 28   N,A,E	⊗&	Step macro execution # steps
 25   N,A,E	⊗≡	Call the macro named "≡"
 25   N,A,E	⊗∩	Call the macro named "∩"
 25   N,A,E	⊗∪	Call the macro named "∪"
 25   N,A,E	⊗⊂	Call the macro named "⊂"
 25   N,A,E	⊗⊃	Call the macro named "⊃"
 25   N,A,E	⊗$	Call the macro named "$"
 25   N,A,E	⊗%	Call the macro named "%"
 25   N,A,E	⊗~	Call the macro named "~"
 25   N,A,E	⊗_	Call the macro named "_"
 24   N,A,E	⊗∂	Operate on message with next cmd
 24   N,A,E	⊗!	Operate on paragraph with next cmd
 15   N,A	⊗ε	Switch to given file in READWRITE mode
 15   N,A	⊗λ	Switch to given file in READONLY mode
 15   N,A,E	⊗∃	Show names of files in fileswitch list
 13   N,A,E	⊗*	Repeat last ⊗F or ⊗XFIND command
 14   N,E	⊗\	Repeat last substitution command
  7   N,A	α.	Write out current page (not including attach buffer)
  7   N,A,E	αβ.	Write out current page (including current line editor)
 15   N,A	⊗?	Switch to the file E.ALS[UP,DOC]/R
 15   N,A	⊗#⊗?	Go to page # in E.ALS
 15   N,A	⊗+⊗#⊗?	Go to E.ALS, # pages beyond where last left it
 15   N,A	⊗-⊗#⊗?	Go to E.ALS, # pages before where last left it
  9   N,E	αβ;	Set col of interest to current col and move straight up
  9   N,E	α;	Move up to next line at old column of interest
  9   N,E	αβ:	Set col of interest to current col and move straight down
  9   N,E	α:	Move down to next line at old column of interest
 22   N,E	⊗(	Find (
 22   N,E	⊗)	Find matching )
 22   N,E	⊗↔	Return to place ⊗(, ⊗) or ⊗↔ was given
 36   N,E	α/	Lisp-indent current line by context above it
 36   N,E	αβ/	Lisp-indent next line by context above it
 36   N,E	⊗#α/	Lisp-indent # lines from arrow by context above
 36   N,E	⊗#αβ/	Lisp-indent # lines from next by context above
 36   A		α/	Lisp-indent first attached line (no-op!)
 36   A		αβ/	Lisp-indent first attached line in context of page
 36   A		⊗#α/	Lisp-indent first # attached lines
 36   A		⊗#αβ/	Lisp-indent first # attached lines in context of page
  9   N,E	α↑	Move to end of line above
 11   N,E,I	αβ↑	Move to end of line above and enter line insert mode
  9   N,E	α↓	Move to end of line below
 11   N,E,I	αβ↓	Move to end of line below and enter line insert mode
 18   N,A,S	⊗←	Shift line or attach buffer left by current indent default
 18   N,A,S	⊗#⊗←	Shift # lines left by current indent default
 18   N,A,S	⊗→	Shift line or attach buffer right by current indent default
 18   N,A,S	⊗#⊗→	Shift # lines right by current indent default
  7   N,A,E	⊗>	Move arrow down 4 lines
  7   N,A,E	⊗<	Move arrow up 4 lines
  7   N,A,E	⊗≥	Move arrow down half a screen
  7   N,A,E	⊗≤	Move arrow up half a screen
  7   N,A,E	⊗∧	Move arrow to top of screen
  7   N,A,E	⊗0⊗∧	Move arrow to middle of screen
  7   N,A,E	⊗∨	Move arrow to bottom of screen
  7   N,A,E	⊗0⊗∨	Move arrow to middle of screen

Page  Modes	⊗X Command	 Meaning

 27   N,A,E	ABORT	    Abort one or more macros levels in progress
 26   N,A,E	ADD	    Add given repeat arg to macro's value
 19   N,A	AL	    Change your job's ALIAS
 19   N,A	ALIAS	    Change your job's ALIAS
 18   N,A,S	ALIGN	    Align left margins of text
  6   N		APPEND	    Add # following pages to incore text
 26   N,A,E	ARGUMENT    Set up repeat argument from value of numeric macro
 27   N		ATTACH	    Place an editable macro definition in the attach buffer
 33   N,A,E	ATTSET	    Set max number of lines used to display attach buffer
 19   N,A,E	AUTOBURP    Set or read autoburping threshold
 28   N,A,E	AUTOSTEP    Set or read autostepping time for macros
 11   N,A,E,I	AUTOWRITE   Set or read autowriting threshold for line insert mode
 34   N,A	BACKGO	    Go back to page that you last came from (see ⊗O cmd)
 19   N,A,E	BEEPME	    Beep the user's terminal now
 19   N,A	BLOAT	    Add extra records of nulls to current page
 33   N,A	BOTSET	    Set number of lines used at bottom for page printer
 12   N,A,S	BREAK	    Break line(s) at given column position
 19   N,A	BURP	    Burp current page of extraneous records of nulls
  6   N,A,E	CA	    Flush unwritten changes to incore page(s)
  6   N,A,E	CANCEL	    Flush unwritten changes to incore page(s)
 25   N,A,E	CASE	    Select and call a macro from a list of macro names
 18   N,A,S	CENTER	    Center text of given lines between margins
 26   N,A,E	CHARACTER   Generate the next command character from numeric value
 19   N,A,E	CHECK	    Enable free storage checking within E
 19   N,A	CLOSE	    Close the file, but allow further editing
 27   N,A,E	COMMENT	    No-op, useful for putting comments in command files
 21   N,A,E	CONTROL     Make next cmd char have only the CONTROL bit
 19   N,A	CORCHK	    Try to core down if possible (done automatically)
 19   N,A,E	DDTGO	    Call RAID, if available (ERAID only)
 25   N,A	DEFINE	    Define a macro
  6   N		DELETE	    Delete the next (not-incore) pagemark
 23   N		DIRED	    Swap to the DIRED directory editor
 26   N,A,E	DIVIDE	    Divide macro's numeric value by given repeat arg
 19   N,A	DPYALWAYS   Update the display after every command
 19   N,A	DPYSKIP     Only update the display when no typeahead
  7   N,A,E	DRAW	    Redraw the screen now
 23   N		DRD	    Swap to the DIRED directory editor
 19   N,A,E	ECHO	    Turn on/off echoing of text edited in line editor
 19   N,A,E	EMPTY	    Move to next empty line on page
 21   N,A	ENTER	    Switch to given file in READWRITE mode
 21   N,A	EPSILON     Switch to given file in READWRITE mode
 13   N,A	EXACT	    Distinguish case of letters in searches
 27   N,A,E	EXECUTE	    Read and execute commands from a file
 21   N,A,E	EXIST	    Type out fileswitch list
 13   N,A,E	FIND	    Do a multipage search for a given string
 23   N		GORPG	    Swap to SNAIL (RPG) to reexecute last cmd
 21   N,A	HEADER	    Type out the header line (from top of window)
 33   N,A	HEIGHT	    Set the number of lines used for text display
 34   N,A	HOME	    Go to relative or absolute page in Home file
 26   N,A,E	IFEQ	    Error unless repeat arg = macro value
 26   N,A,E	IFGE	    Error unless repeat arg ≥ macro value
 26   N,A,E	IFGT	    Error unless repeat arg > macro value
 26   N,A,E	IFLE	    Error unless repeat arg ≤ macro value
 26   N,A,E	IFLT	    Error unless repeat arg < macro value
 26   N,A,E	IFNE	    Error unless repeat arg ≠ macro value
 18   N,A,S	INDENT	    Indent lines by given amount
  6   N		INSERT	    Insert an incore pagemark before current line
 16   N,A,S	JFILL	    Justify paragraphs w/out aligning right margin
 16   N,A,S	JGET	    Get justification margins from text
 12   N,A,S	JOIN	    Join two or more lines by deleting CRLFs
 16   N,A,S	JUST	    Justify paragraphs and align at right margin
 21   N,A	LAMBDA	    Switch to given file in READONLY mode
 19   N,A	LINCNT	    Type length of current line, plus more info
 36   N,A,E	LISPSYNTAX  Examine and/or modify char interpretation by ⊗/ cmd
 21   N,A	LOOKUP	    Switch to given file in READONLY mode
 22   N,E	LPAREN	    Search for next "(", crossing page boundaries
  6   N,A	M	    Make the current line start a new page
 19   N,A,S	MAIL	    Mail a message to someone
  6   N,A	MARK	    Make the current line start a new page
 26   N,A,E	MAXIMUM	    Set macro's value to MAX(<old value>,<repeat arg>)
 21   N,A,E	METACONTROL Make next cmd char have both META and CONTROL bits
 26   N,A,E	MINIMUM	    Set macro's value to MIN(<old value>,<repeat arg>)
 21   N,A,E	MSG	    Operate on current message with next command
 26   N,A,E	MULTIPLY    Multiply macro's numeric value by given repeat arg
 32   N		NDBBOARD    Make a New Directory line for a page in \BBOARD
 32   N		NDFAIL	    Make a New Directory line (FAIL type) for page
 32   N		NDSAIL	    Make a New Directory line (SAIL type) for page
 19   N,A,E	NONEMPTY    Move to next non-empty line on page
 21   N,A,E	NUMBERS     Enable or disable typing of line numbers with text
 19   N,A	OPEN	    Open the current file in Read-Alter mode
 22   N,A,E	PAREN	    Set the chars searched for by parenthesis cmds
 21   N,A,E	PARTIAL     Operate on current message with next command
 22   N,A,E	PINFO	    Type out info about last parenthesis command
 15   N,A	POINTER	    Switch to a file named in the incore text
 19   N,A	PPSET	    Ensure that the page printer is positioned ok
 19   N,A	PROTECTION  Set or read the protection key of the file
 27   N,A,E	PUTDEFS	    Write out all current macro definitions in a cmd file
 19   N,A,E	QUIT	    Exit to monitor without writing out the file
 25   R,A,E	RAPID	    Enable line editor simulator for use in macros
 19   N,A	READONLY    Disallow changing the file
 19   N,A	READWRITE   Allow changing the file
 27   N,A	REDEFINE    Define a macro from incore page or attach buffer
 26   N,A,E	REMAINDER   Set macro to remainder of <old value> / <repeat arg>
 19   N,A,S	REMIND	    Enter a REMIND-system reminder
 25   N,A,E	RESUME	    Resume expansion of a macro that was stopped early
 22   N,E	RPAREN	    Search for next ")", crossing page boundaries
 23   N,A,E	RSYS	    Run a given system program, with RPG startup
 23   N,A,E	RUN	    Run a given user program, with RPG startup
 19   N,A	SAVE	    Write out incore page(s) in E$SAVE.TXT
 28   N,A,E	SAY	    Type out text and/or decimal number
 19   N,A,S	SEND	    Send a message to someone logged in
 26   N,A,E,S	SET	    Set the value of a numeric macro
 25   N,A,E	SILENT	    Suppress error messages while inside macros
 19   N,A,S	SIN	    Replace tabs with equivalent numbers of spaces
 16   N,A,S	SJFILL	    Separate text into justified sentences
 16   N,A,S	SJUST	    Separate into justified right-aligned sentences
 19   N,A,S	SPOOLC	    Spool incore page(s) on the line printer
 13   N,A,E	SSLINE	    Set or report the search limiting line number
 13   N,A,E	SSPAGE	    Set or report the search limiting page number
 28   N,A,E	STEP	    Step macro execution # steps
 25   N,A,E	STOPALL	    Set action on macro error to stop all macros
 25   N,A,E	STOPHOW	    Find out setting of macro error action
 25   N,A,E	STOPONE	    Set action on macro error to stop just one macro
 25   N,A,E	STOPZERO    Set action on macro error to ignore errors
 26   N,A,E	SUBTRACT    Subtract given repeat arg from macro's value
 17   N,A,S	TABLE	    Line up entries in a table
 19   N,A,E	TELLME	    Report the latest commands to person maintaining E
 19   N,A,E	TERSE	    Enter terse mode--suppresses some typed info
 17   N,A,S	TGET	    Same as TJGET command (see below)
  6   N,A	THISPAGE    Write out incore page(s) and read back only current page
 19   N,A,S	TIN	    Replace multiple spaces with equivalent tabs
 17   N,A,S	TJFILL	    Justify paragraphs that begin with a table
 17   N,A,S	TJGET	    Get margins for TJFILL/TJUST from text
 17   N,A,S	TJUST	    Justify & R-align paragraphs beginning w/table
 19   N,A,E	TMPCOR	    Write out (now and on exit) TMPCOR file used by E
 33   N,A	TOPSET	    Set number of lines E skips at top (e.g., for wholine)
 21   N,A	TRAILER	    Type out the trailer line (from bottom of window)
 21   N,A,S	TYPE	    Type out line(s) of text
 35   N,A	UNDELETE    Restore recently deleted or changed text
 30   N,A	UPDATE	    Write out the updated incore directory
 19   N,A,E	VERBOSE     Enter verbose mode--types out extra info
 19   N,A,E	WRITTEN     Type out who previous wrote the file and when
 19   N,A,S	XSPOOL	    Spool incore page(s) on the XGP
 34   N,A	ZFILES	    Zero (clear) the file stack (and filelist)
 34   N,A	ZLINES	    Zero (clear) the line stack
  8   N,A	ZMARKS	    Zero (clear) all line marks
 34   N,A	ZPAGES	    Zero (clear) the page stack
Abbreviations and explanation of E documentation.  Credits.

This version of the E manual is intended for on-line use by the normal
user.  It may be referenced at any time while editing another file
simply by typing a <CONTROL>? command.  One may always return to one's
original file by typing the <CONTROL>H command.

   A simplified form of this manual for the beginner is available by
typing HELP ETEACH with a carriage return to the system.  This copies a
file named TEACH into one's file area and allows one to read it and
modify it for practice.

   This is p. 4 of E.ALS[UP,DOC] (see the top line with asterisks).
Page 1, the "directory" page, is automatically prepared by E, and in
this case has been planned to be of maximum help to the user.  There is
also an Index of Commands on p. 3.

ABBREVIATIONS used in this manual and in TEACH to characterize commands.

   α     means hold the "CONTROL" key down while typing a character.
   β     means hold the "META" key down while typing a character.
   αβ    means hold both "CONTROL" and "META" keys down while typing.
   ⊗     means use either α or αβ with the next character.

   Most commands are single characters with one or both of the two keys.

		Additional abbreviations
   <cr>    carriage RETURN key.			<lf>    LINE feed key.
   <tab>   TAB key.				<alt>   ALT-mode key.
   <bs>    Back-Space key.			<form>  FORM-feed key.
   <vt>    the VT key.				<clear>	the CLEAR key.
   CURRENT means the current line (normally with an → or ↔ on the left).


Credits.

   Dan Swinehart wrote TV, the original version of the display editor,
and created the original version of TEACH.  Fred Wright wrote the FAIL
version of TV (called E).  Brian Harvey modified TEACH to reflect
differences between E and TV.  Arthur Samuel and Brian Harvey are
responsible for this version.  Address all comments and questions to
Samuel, who is currently trying to fix the remaining bugs in E.

Disclaimer.

   An attempt has been made to present a coordinated view of E.  To this
end some simplications have been made.  The experienced user may develop
techniques that are not described in this manual.  Any outright errors
should, however, be called to our attention.
General remarks.

    E is a fast display-oriented text editor for disk files.  By using
random access to individual pages, E can move around quickly within a
file without having to be continually recopying the file; and only those
pages whose texts are changed are ever written out to the disk.  E keeps
one or more contiguous pages in core and, on display terminals, shows to
the user a portion of this text as if through a window, thus showing
lines of text in context rather than isolated.  Various commands are
available for moving the window from place to place in the file and for
moving around within the window.  (Normally only one page is kept in
core, but the user can cause several contiguous pages to be kept in core
to provide even faster movement among those pages.)  On displays, a line
pointer (arrow) and an underscoring cursor are used to mark the position
in the text where editing is to occur.  On non-display terminals, text
is typed out instead of displayed.

    Note: On Datamedia terminals (DMs), no arrow is used to indicate the
current line.  Instead, the terminal's cursor is left under the first
character of the current line.

    The window of text on a display screen is bordered above and below
by lines consisting mainly of asterisks or dots but which also include
information about the editing.  A top or bottom border will be mostly
ASTERISKS when the last text line in that direction is visible
ON-SCREEN, and the border line will be mostly DOTS when there is more
text OFF-SCREEN in that direction.

    The border line at the top is called the header line, and the border
line at the bottom is called the trailer line.  The information on the
header line includes:
	(1) the number of the text line just below the header,
	(2) the number(s) of the incore page(s),
	(3) the name of the file, and
	(4) the editing modes.
The trailer line reports:
	(1) the number of the current line,
	(2) the total number of lines on the current page,
	(3) the number of the current page,
	(4) the total number of pages in the file, and
	(5) some information about the size of the page(s) in core.
This last item tells the page's size with respect to the number of
records that it currently occupies on the disk.  The amount of room the
page currently uses on the disk is given in records followed by the
letter "R".  Following this is a number that shows how much spare room
there is for this page on the disk or how much extra room the page needs
in order to write it out to the disk.  The amount of spare room or extra
room needed is reported in characters and is followed by the letter "C"
provided the number is 640 characters or less.  In this case, a negative
number means there is that much room to spare and a positive number
means that much extra room is needed.  If the amount of spare or extra
room is more than 640 characters, it will be reported in records (640
characters/record) and will be followed either by the letter "B" (for
Bloated) if there is room to spare or by the letter "X" (for eXpand) if
more room is needed.

    If the file is not formatted, only a "?R" will appear where normally
the R and C/B/X fields appear.

    Extra records indicated by a "B" on the trailer line will never be
removed automatically, although they can be removed by the ⊗XBURP
command.

    E does not make a separate disk copy of the file being edited unless
that is requested by the use of a special command (described later), so
take care--when you write out a page, the former contents of that page
are lost.

    Basic editing in E (on displays) utilizes the system line editor for
editing a single line at a time.  E loads text from the current version
of a text line into the display's line editor and then lets you edit it
with the usual system line editor commands.  When you are done with the
line, you type <cr> (or some other command) to give the edited text back
to E.

    E achieves its speed (1) by using the system's line-editor and only
changing the core copy of the text on the completion of a line edit, and
(2) by updating the disk copy of the page only on the completion of a
page edit (automatically effected by moving to another page).  You can
undo an entire page of incorrectly made modifications by cancelling an
update, but unfortunately, you can also lose an entire page of desired
modifications or additions if the system should go down unexpectedly.

    E is best understood by recognizing that it operates in a few
different modes and that many commands are appropriate only to certain
modes.  In fact, a couple of commands have quite different effects
depending upon the mode that E is in at the time when the command is
given.

    The dominant mode is the NORMAL mode.  This allows for page, window
and line pointer movement commands and commands which enter the other
modes.
PAGE CHANGING, APPENDING, DIVIDING, COMBINING, CANCELLING: ⊗XAPPEND ⊗XTHISPAGE β<ff> ⊗XMARK ⊗XDELETE ⊗XCANCEL

  Modes     Command	    Meaning
  N	    β<form> Insert an incore pagemark
  N,A	    αP	    Go to next Page
  N,A	    αβP     Go to next Page that is not in core
  N,A	    ⊗-αP    Go to previous Page
  N,A	    ⊗-αβP   Go to previous Page that is not in core
  N,A	    ⊗#αP    Go to Page #
  N,A	    ⊗#αβP   Go to Page #, retaining only it in core
  N	    APPEND	Add # following pages to incore text
  N,A,E     CA		Flush unwritten changes to incore page(s)
  N,A,E     CANCEL	Flush unwritten changes to incore page(s)
  N	    DELETE	Delete the next (not-incore) pagemark
  N	    INSERT	Insert an incore pagemark before current line
  N,A	    M		Make the current line start a new page
  N,A	    MARK	Make the current line start a new page
  N,A	    THISPAGE	Write out incore page(s) and read back only current page


PAGE CHANGING commands.

   PAGE-CHANGING commands are single characters typed with the CONTROL key
held down or with both the CONTROL and the META keys held down.  They may
take modifiers as shown below.  Note: if you have more than one page in
core, then there is a slight difference between the commands αP and αβP.

   αP	    Go to the next Page.
   αβP      Go to the next Page that is not already in core.

   ⊗7αP	    Go to page 7.
   ⊗7αβP    Go to page 7, retaining only it in core.

   ⊗+⊗4αP   Go forward 4 pages.
   ⊗+⊗4αβP  Go forward 4 pages from the last page in core.

   ⊗-αP     Back up to the previous page.
   ⊗-αβP    Back up to the previous page that is not already in core.

   ⊗-⊗3αP   Back up 3 pages.
   ⊗-⊗3⊗P   Back up 3 pages from the first page in core.

   It is good practice to limit the page size to less than 150 lines.
This eases the load on the editor and makes the directory of more use.
The directory will be much more useful if you also make it a practice to
start each page with a suitable comment, in the case of code perhaps
containing a list of all labels to be found on the page.  You can than
use a special directory search procedure (explained on p. 13) to expedite
the location of any desired item that is so listed.


PAGE APPENDING and UNAPPENDING commands.

It is possible to have more than one page in core at the same time.  This
technique makes it possible for two pages to be edited together at the
same time while retaining all of advantages of short pages, as noted above.
To do this one makes use of the ⊗XAPPEND command.

  ⊗#⊗XAPPEND    Read in # additional pages after the current one(s) so
		that two or more contiguous pages may be edited together.
		If no arg (#) is given, one additional page is read in.
		This command is not legal from the directory page or in
		an unformatted file.  The arrow may be moved up and down
		freely on the combined incore pages and the αP command
		(with an argument if desired) may be used to switch
		between the incore pages, without affecting the APPEND
		status.  αβP commands will, however, write out all incore
		pages and read in only the one specified.  The ⊗XCANCEL
		command (below) cancels all corrections on all of the
		incore pages and reads in the previous version of the
		first incore page.

  ⊗XTHISPAGE    This command is useful for going from multipage mode (two
		or more pages in core, from having done an ⊗XAPPEND or a
		β<ff>) to single page mode (one page in core).  This
		command writes out the incore text and then reads in only
		the page where the arrow is.  The position of the arrow
		and (when possible) the window are preserved.  However,
		the line stack is currently cleared.


PAGE DIVIDING commands

A page may be split into two pages in either of two ways, one way
leaving only the newly created page in core and the second way leaving
both pages in core together.

  ⊗XMARK
    or
   ⊗XM		Split the current page into two pages with the arrow line
		as the first line of a new page.  Write out the incore
		pages and retain in core only the page containing the
		arrow line.

		If this command is given when there is some text attached,
		the attached lines are first put down and then the page is
		divided in two and written out.  The division occurs at
		the beginning of the formerly-attached lines unless those
		lines are already at the top of a page, in which case the
		division occurs after the formerly-attached lines.  The
		arrow is left at the top of the formerly-attached lines,
		whose page is the only one retained in core.

  β<form>	Split the current page into two pages with the arrow line
		as the first line of the newly created page and retain
		both pages in core without writing out anything.

  ⊗XINSERT	Exactly the same as β<form>.


PAGE COMBINING commands

Two pages may be combined into one page in either of two ways.

  ⊗XDELETE<cr>	Delete the pagemark at the end of the last incore page
		and add the text that was formerly on the next page to
		the present in-core page, writing out the resultant page.

To delete a page mark that divides two pages that are already in core
togather, one moves the arrow to the on-screen representation of the
page mark separating the two pages and gives the following command.

  αβD		When this command is given with the arrow pointing to an
		on-screen page mark, the page mark is deleted and the two
		adjoining pages are combined into one page.  Thus, this
		command will delete either regular text lines or pagemark
		lines (without writing out any pages).


PAGE RESTORING command

   ⊗XCANCEL     Do not write out the current page but instead reread it in
      or	from the disk.  If several pages are in core, only the
     ⊗XCA	first of those is reread from the disk.  See p. 8 for the
		effect ⊗XCANCEL has on line marks.
WINDOW and ARROW moving commands.

  Modes     Command	    Meaning
  N,A	    <form>  Go forward one window among incore text
  N,A	    ⊗0<form> Go forward a half window among incore text
  N,A	    ⊗#<form> Go forward # windows among incore text
  N,A	    ⊗<form> Go forward one window, changing pages if necessary
  N,A	    <vt>    Go back one window among incore text
  N,A	    ⊗0<vt>  Go back a half window among incore text
  N,A	    ⊗#<vt>  Go back # windows among incore text
  N,A	    ⊗<vt>   Go back a window, changing pages if necessary
  N,A	    β<vt>   Go back a window, changing pages if necessary
  N,A	    <cr>    Move arrow to next line
  N,A	    <bs>    Move arrow up a line
  N,A	    β<bs>   Move arrow up a line
  N,A	    ⊗<bs>   Move arrow up a line (see also ⊗U cmd)
	    <ESC>I  Terminate wait on delayed ⊗V command
  N,A	    ⊗B	    Glitch screen up from Bottom
  E	    αβB     Glitch screen up from Bottom
  N,S	    αβD     Delete line
  N,S	    ⊗#αβD   Delete # lines
  N,S	    ⊗-αβD   Delete previous line
  N,S	    ⊗-⊗#αβD Delete # previous lines
  N	    ⊗E	    Exit
  N,A,E     ⊗J	    Jump the arrow line to the top of the screen
  N	    ⊗-⊗J    Jump the arrow line to the bottom of the screen
  N,A,E     ⊗0⊗J    Jump the arrow line to the center of the screen
  N	    ⊗#⊗J    Jump the arrow line up # lines
  N	    ⊗-⊗#⊗J  Jump the arrow line down # lines
  N,A	    αL	    Go to first line of current page
  N,A,E     αβL     Go to first line of incore text
  N,A,E     ⊗#αL    Go to Line # of current page
  N,A,E     ⊗#αβL   Go to Line # of all incore text
  N,A	    ⊗T	    Glitch screen down from Top
  E	    αβT     Glitch screen down from Top
  N,A,E     ⊗U	    Move arrow Up a line (recommended cmd for non-displays)
  N,A,E     αV	    Redraw screen (without clearing)
  N,A,E     αβV     Clear and then redraw screen
  N,A,E     ⊗#⊗V    Redraw screen and then wait # seconds; ESC I ends wait
  N,A,E     ⊗W	    Go forward one window among incore text
  N,A,E     ⊗0⊗W    Go forward a half window among incore text
  N,A,E     ⊗#⊗W    Go forward # windows among incore text
  N,A	    α.	    Write out current page (not including attach buffer)
  N,A,E     αβ.     Write out current page (including current line editor)
  N,A,E     ⊗>	    Move arrow down 4 lines
  N,A,E     ⊗<	    Move arrow up 4 lines
  N,A,E     ⊗≥	    Move arrow down half a screen
  N,A,E     ⊗≤	    Move arrow up half a screen
  N,A,E     ⊗∧	    Move arrow to top of screen
  N,A,E     ⊗0⊗∧    Move arrow to middle of screen
  N,A,E     ⊗∨	    Move arrow to bottom of screen
  N,A,E     ⊗0⊗∨    Move arrow to middle of screen
  N,A,E     DRAW	Redraw the screen now


These are Normal-mode commands.  The CURRENT line is marked by an arrow
and is the line that would be processed if one were to enter the line-
editor.  In the descriptions below it will be referred to as the arrow
line.

The first set of commands control the position of the window on the page.
The arrow is usually repositioned by these commands.

 <form>	  Advance the window, that is, move the last line to the top.  This
	  command (without control bits) does not advance the window beyond
	  the range of the in-core text.
	  An argument may be used (typed with control bits and preceding
	  the <form) to define the number of windowfuls to be advanced.
  ⊗W	  This is an older (still functioning) command to do the same thing.

 ⊗4<form> Advance 4 window among the incore text.
 ⊗4⊗W	  Same thing.

 ⊗0<form> Advance half a window.
 ⊗0⊗W	  Same thing.

 ⊗<form>  Advance the window as defined above but move to beginning of the
	  next page if the the end of the in-core text is already within
	  the window.

 β<form>  This command is NOT a window moving command (see p. 6 for its
	  explanation).  Do not confuse it with <form> or ⊗<form>.

  <vt>	  Move the window up so that the first line becomes the LAST.  This
	  is the reverse of <form>.  This command without control bits does
	  not back up beyond the range of the in-core text.
  
 ⊗3<vt>	  Back up 3 windows among the incore text.

 ⊗0<vt>	  Back up half a window.

 ⊗<vt>    Move the window up so that the first line becomes the LAST.  This
  or	  command (with any control bits), will move to the end of the
 β<vt>	  preceding page if the start of the in-core text is already within
	  window.  If any arg is given, that many windows are backed up,
	  but only among the incore text.


The following commands leave the page, window and arrow unchanged but
they refresh the screen.  If any of these commands is typed ahead, the
screen will be redrawn immediately when the command is encountered,
despite any further type-ahead.

  αV	  Redraw the screen WITHOUT first clearing it (the fastest).

  αβV	  Clear the screen and then redraw it (this is slower on Data Discs).

  ⊗3⊗V	  Redraw screen as above then wait 3 seconds before continuing.
	  <esc>I will terminate the wait.

  ⊗XDRAW  Exactly the same as ⊗V (in various forms explained above).


The following commands move the position of the window on the page, leaving
the arrow so that it still points to the same line of the text, if this is
possible, otherwise causing it to point to the first or last line on the
window.

   ⊗J     Move (JUMP) the window so that the arrow line is at the top.
   ⊗0⊗J   Move (JUMP) the window so that the arrow line is at the middle.
   ⊗-⊗J   Move (JUMP) the window so that the arrow line is at the bottom.

   ⊗3⊗J   Move (JUMP) the window so that the arrow line is 3 lines higher
	  in the window (with the top as the limit).
  ⊗-⊗7⊗J  Move (JUMP) the window so that the arrow line is 7 lines lower
	  in the window (with the bottom as the limit).

          Note that  the  default argument  for the  J  commands is,  in
          effect, infinity, with the argument 0 having a special meaning
          rather than being a undefined.

   ⊗T     Glitch the screen so that 4 additional lines are displayed at the
   or	  top (⊗T) or bottom (⊗B) of the screen.  An argument, if used, is
   ⊗B	  in multiples of 4 lines of glitching.  If either of these
	  commands is given from the line editor, then αβ must be used
	  (the α version will be a line editor command instead) and the
	  the arrow is maintained on the same text line, which is not
	  permitted to move beyond the edge of the screen, and you are
	  left still in the line editor.

The following commands move the arrow with respect to the window, without
moving the window.
   ⊗∧	  Move the arrow to the top line in the window.
 ⊗3⊗∧	  Move the arrow to the line that is 3 down from the top of the
	  window.
 ⊗9⊗9⊗∧	  Since this would be off of the window the arrow is simply moved to
	  the bottom of the window.  (The next command does this more easily).
   ⊗∨	  Move the arrow to the bottom line in the window.
 ⊗4⊗∨	  Move the arrow to the line that is 4 up from the bottom of the
	  window.

 ⊗0⊗∧	  Move the arrow to the middle of the screen.
 ⊗0⊗∨	  Move the arrow to the middle of the screen.


The following commands move the arrow with respect to the text.  Should this
require the arrow to leave the currently displayed window, the window is
shifted, usually so that the arrow line will be in the middle of the window.

   <cr>   Move the arrow down a line, unless at row of stars.
   ⊗>     Move the arrow down 4 lines.
   ⊗≥     Move the arrow down 1/2 screen.

   <bs>   Move the arrow up a line (cannot be typed ahead on non-displays).
   ⊗U     Move the arrow up a line (works better than <bs> on non-displays).
   ⊗<     Move the arrow up 4 lines.
   ⊗≤     move the arrow up 1/2 screen.

   αL	  Move the arrow to the first line of the current page.
   αβL	  Move the arrow to the first line of all the incore text.
  ⊗5αL	  Move the arrow to the 5th line of the current page.
  ⊗5αβL	  Move the arrow to the 5th line of all the incore text.
  ⊗∞αL	  Move the arrow to the end of the current page.
  ⊗∞αβL	  Move the arrow to the end of all the incore text.

The following comands move the arrow with respect to the text, as above,
AND  they enter the LINE-EDIT mode.  They may also be given when in the
LINE-EDIT mode (see p. 9) but they then require αβ with the arguments.

  α↑        Enter the LINE-EDIT mode with the cursor at the end of the
	    previous line.
  αβ↑	    Enter LINE INSERT mode with the cursor at the end of the
	    previous line.  See also p. 11.
  ⊗3α↑      Enter the LINE-EDIT mode with the cursor at the end of the
	    third previous line.
  α↓        Enter the LINE-EDIT mode with the cursor at the end of the
	    next line.
  αβ↓	    Enter LINE INSERT mode with the cursor at the end of the
	    next line.  See also p. 11.
  ⊗6α↓      Enter the LINE-EDIT move with the cursor at the end of the
	    sixth line forward.
   
The following commands remove text lines from the page.

   αβD    DELETE the entire CURRENT line.
	  This takes both α and β since αD has a different meaning.
	  Use with caution, the only way to undo a line deletion is
	  to cancel all corrections to the current page that have
	  been made since the last disk update.

   ⊗4αβD  Delete 4 lines starting with CURRENT.

Here are some commands that save the currently edited page on the disk.
Note: the current page is saved automatically whenever you change pages.
Also, whenever the page is written out, any text in the attach buffer
is excluded from that being written out.

   α.	  Write the current page (as corrected) into the disk file.
	  This command is legal only from NORMAL MODE.
   αβ.	  This command also writes out the current page, but it works
	  from NORMAL, LINE-EDIT and LINE INSERT modes.  Thus it can be
	  given from within the line editor to write out the page
	  (including the current version of the arrow line) without
	  having to get out of the line editor.
   ⊗E     Do a α. and then EXIT to the system.  This is not a legal
	  command to execute during macro expansion because the same
	  command is used to put down any attach buffer (see p. 10).
	  After you exit from E, you can get back into E at the same
	  place by immediately using the system command CONTINUE.

Most of the NORMAL-MODE commands require the use of the CONTROL key (α)
and perhaps the META key (β).  Exceptions are <cr>, <bs>, <form> and <vt>.
LINE MARKING commands.

  Modes     Command	    Meaning
  N,A	    αM	    Go forward to next Mark
  N,A	    ⊗-αM    Go backward to previous Mark
  N,A	    ⊗#αM    Go forward # Marks
  N,A	    ⊗-⊗#αM  Go backward # Marks
  N,A	    αβM     Place a Mark on current line
  N,A	    ⊗-αβM   Clear Mark on current line
  N,A	    ⊗0⊗M    Report the number of Marks in current file
  N,A	    ZMARKS	Zero (clear) all line marks


E provides the facility of marking up to 23 line locations with a rapid
way to return to these locations by using the following commands.

Marks are relative with respect to the line locations on the page but the
stored values are corrected for line and page insertions and deletions so
that the marks appear to stick with particular text lines.  However, the
justification commands and the line-breaking and line-joining commands do
not adjust marks properly, so those commands may cause the marks to move
slightly from the originally marked text lines.

Marks do not accompany attachments and they do not disappear when lines
are deleted.  Instead, marks on lines that are attached or deleted are
moved to the first remaining line after the attachment or the deletion.

The ⊗XCANCEL command resets the marks for the page being cancelled to the
values they had when this page was last saved by an αβ. or page changing
command.  Incidentally, if all marks, including those on other than the
current page, are removed by an ⊗XZMARKS command, they may all be restored
by the ⊗XCANCEL command, (if this is done before any page saving command)
with, of course, the accompanying restoring of the text of the current
page.

Marks are saved during ⊗ε, ⊗λ, ⊗? and ⊗H file-switching operations and are
restored on returning to a previously marked file.

       αβM  Plant a line mark at the current line on the current page.
     ⊗-αβM  Clear the line mark (if any) on the current line.

        αM  Go forward to the next line mark (cyclicly).
      α2αM  Go forward to the second line mark found (cyclically).
      α-αM  Go backward to the first previous line mark (cyclicly).
    α-α3αM  Go backward to the third line mark found (cyclically).

  ⊗XZMARKS  Clear all line marks.
⊗-⊗XZMARKS  Clear all line marks on the current page.
LINE-EDIT commands.

  Modes     Command	    Meaning
  E,L	    α<form> Move cursor to beginning of line
  E	    <cr>    Close line and move arrow to next line
  E	    α<cr>   Leave LINE-EDIT mode, stay on same line
  N	    β<cr>   Insert <cr>
  E	    β<cr>   Close line and insert <cr>
  I	    β<cr>   Insert <cr> but don't leave LINE INSERT mode
  E,L	    <bs>    Move cursor left a char, deleting if at end of line
  E,L	    α<bs>   Move cursor to left (never deleting char)
  E,L	    β<bs>   Delete char to left
  E,L	    αβ<bs>  Repeatedly move cursor to left (as long as held down)
  N,E,L     α<tab>  Go to end of current line
  E	    <alt>   Restore line to original condition
  E,L	    αB	    Move backwards in line editor to next char typed
  E,L	    αD	    Delete char (if at end of line, delete CRLF)
  N,E,L     αI	    Enter Insert mode (at end of line, enter LINE INSERT mode)
  N,E,L     αK	    Kill characters forward up to next char typed
  E,L	    αL	    Kill characters backward up to next char typed
  N,E	    ⊗Q	    Copy line above, and enter copy in line-edit mode
  N,E,L     αR	    Repeat line editor αS or αK or αB or αL cmd
  N,E,L     αS	    Skip to next char typed
  E,L	    αT	    Transpose the previous two chars in the line editor
  N,E	    αβ;     Set col of interest to current col and move straight up
  N,E	    α;	    Move up to next line at old column of interest
  N,E	    αβ:     Set col of interest to current col and move straight down
  N,E	    α:	    Move down to next line at old column of interest
  N,E	    α↑	    Move to end of line above
  N,E	    α↓	    Move to end of line below


   E uses the line-editing commands that are a part of the operating
system.  There is a limit (usually 133) to the number of characters that
the line editor can handle.

   Typing a character without a CONTROL or META key will normally invoke
the line editor and the character is typed into the CURRENT line.  A
cursor will appear under the first character in the line and in that
position where the next typed character will go.  A character so typed
overwrites the character that was at the cursor's position.  E will be
in the LINE-EDIT mode.

   A word of caution--it is usually safe to continue typing on entering
the LINE-EDIT mode without waiting for the system to catch up.  Most of
the earlier bugs that caused this to fail have been fixed but it is wise
to look before giving a carriage return and if anything is amiss to type
<alt> and start over again.

   When the arrow appears to point at the bottom row of asterisks
(which, of course, is not in the text) E will accept anything that is
typed as an added line of text.  The asterisks temporarily disappear
only to reappear below the new line on the completion of the addition,
and E reverts to the NORMAL mode.

   When in the LINE-EDIT mode a <cr> will terminate the mode and move
CURRENT to the next line.  A α<cr> will terminate the LINE-EDIT mode
without moving CURRENT.  Remember that the line corrections do not
appear in the core image until you leave the line-editor mode.

   Also remember that the version on the disk still does not show your
corrections until a disk update has been initiated.  When in this
intermediate state the letter W will appear at the end of the title line
(with asterisks or dots at the top of the window, meaning that something
is yet to be written.

   If your change will require the directory to be changed, this will be
shown by the letter D in this top line.  The letter X can also appear if
the change requires an extension in the space on the disk assigned to
the current page.  The letter X also appears on the trailer line with a
number specifying the number of extra records (of 128 words) that will
be required.  If no extra records are required this X is replaced by the
letter R following a number specifying the number of records that the
page occupies or will occupy on the disk.  After a deletion the letter B
may appear in place of this R or X, again preceded by a number that
specifies the number of all-null records that the page will contain.

   By the way, window moving commands do not automatically update the
disk, whereas page changing commands always do an update.

   Most of the line editing commands listed below will also enter the
LINE-EDIT mode from the NORMAL mode, except when the arrow is pointing
either at the row of asterisks (at the end of the page) or at an incore
pagemark.  However, the following line editor commands will not enter
LINE-EDIT mode from NORMAL mode, where they have different meanings:
αT, αB, αL, α<form>, <bs> and ⊗<bs>.

   If you make a mistake and perhaps lose some valuable information hit
<alt> rather than <cr> and your data will reappear as if by magic.

The following commands move the cursor without changing the line.

   α<space>   Move the cursor  to the right 1 space.
   α4α<space> Move the cursor 4 spaces  to the  right.
   α<bs>      Move the cursor to  the left  1 space.
   α5α<bs>    Move the cursor 5 spaces to the left.
   α<tab>     Move the cursor to the end  of the line.
   α<form>    Move the cursor to the start of the line.

   αS then <char>    Move the cursor to the next occurrence of <char>.
   α3αS then <char>  Move the cursor to the 3rd next occurrence of <char>.

   αB then <char>    Move cursor backwards to nearest occurrence of <char>.
		     This command will not enter the line editor from NORMAL
		     mode, where it has a different meaning.
   α3αB then <char>  Move cursor backwards to 3rd nearest occurrence of <char>.

The following commands allow you to insert or delete characters.

  β<char>   Make  room and  insert  <char>  ahead  of the  cursor
	    position.

   αD       DELETE a character and move the rest of the line to the
	    left.  If at the end of the line,  this will append the
	    next line to the current one.  E will prevent this from
	    being done if the resulting line would be too long for
	    the line editor.
  α4αD	    Delete 4 characters starting at the cursor position but do not
	    append the next line should the count exceed the number of
	    remaining characters in the line (unless command is given when
	    cursor is at the end of the line).

  αK<char>  KILL the line starting with the cursor position up to but
	    not including the character typed.  Do nothing if the no
	    such character is found.
  αK<cr>    Kill the rest of the line starting with the cursor position.

  α4αK<char>  KILL the line up to the 4th occurrance of the character.

  αL<char>  KILL BACKWARDS starting with the previous character on back to but
	    not including the character typed.  Do nothing if the no
	    such character is found before the cursor.  This command will
	    not enter the line editor from NORMAL mode, where it has a
	    different meaning.
  αL<cr>    Kill BACKWARDS everything before the current character.

  α4αL<char>  KILL backwards everyting back to the 4th occurrance of the character.

The following command allows you to correct one of the most common typing errors.

  αT	    Reverse the order of the two characters just ahead of the cursor.
	    This command will not enter the line editor from NORMAL mode,
	    where it has a different meaning.

The following commands allow you to leave the LINE-EDIT mode.
  α<cr>     Accept the line, leave LINE-EDIT mode but do not move the arrow.
  <cr>      Accept the line, leave LINE-EDIT mode and  move the arrow down.
  ⊗U   	    Accept the line, leave the line-edit mode and move arrow up
	    one line.

For completeness the <cr> and <bs> commands are listed togather to
remind you that they do quite different things depending upon the
associated control keys.

  <cr>      Accept the line, leave LINE-EDIT mode and  move arrow down.
  α<cr>     Accept the line, leave LINE-EDIT mode but do not move arrow.
  β<cr>	    Insert a <cr> before the cursor position; leave LINE-EDIT mode
	    (unless in LINE INSERT mode) but do not leave LINE INSERT mode.
  αβ<cr>    Break line at cursor and enter LINE INSERT mode (see p. 11).

  <bs>      BACK SPACE, deletes like β<bs> if at the end of the line,
	    otherwise just moves the cursor to the left like α<bs>.
  α<bs>	    Move cursor to the left WITHOUT deleting.
  β<bs>     Delete the character to the left of the cursor position.
  αβ<bs>    Repeatedly move cursor to left (as long as held down).

The following commands allow you to enter or leave the INSERT mode.

  αI	    Enter INSERT mode (like holding META down continuously).
	    Everything that you type (including carriage returns) will
	    be inserted until you type another line editor command.  If
	    you give this command while at the end of a line, you will
	    enter LINE INSERT mode (see p. 11) instead of INSERT mode.
  αβI       Enter LINE INSERT mode (see p. 11).
  α<cr>	    Accept the line, leave Insert or LINE INSERT mode but do not 
	    move arrow.
  <alt>     Restore the line to it original condition and leave the
	    LINE-EDIT mode.  (See p. 11 for its action when in
	    LINE INSERT mode.)

The following commands allow you to leave the line-edit mode, move to
another line and reenter the line-edit mode, all with one command.

  α↑        Accept the line, then move to the end of the previous line.
  αβ3α↑     Accept the line, then move to the end of the third previous
	    line.
  α↓        Accept the line, then move to the end of the next line.
  αβ6α↓     Accept the line, then move to the end of the sixth line
	    forward.

  αβ↑	    Enter LINE INSERT mode with the cursor at the end of the
	    previous line.  See p. 11.
  αβ↓	    Enter LINE INSERT mode with the cursor at the end of the
	    next line.  See p. 11.

  α;        Accept the line, then edit the PREVIOUS line at the "column of
	    interest" defined by the last αβ; or αβ: command.
  αβ;       Set the "column of interest" (for the α; and α: commands) to
	    the current column, then accept the current line and edit the
	    PREVIOUS line at the new "column of interest".
  αβ3α;     Accept the line, then edit the third PREVIOUS line at the
	    "column of interest" defined by the last αβ; or αβ: command.
  αβ3αβ;    Like αβ3α; after setting the column of interest to current column.

  α:        Accept the line, then edit the NEXT line at the "column of
	    interest" defined by the last αβ; or αβ: command.
  αβ:       Set the "column of interest" (for the α; and α: commands) to
	    the current column, then accept the current line and edit the
	    NEXT line at the new "column of interest".
  αβ6α:     Accept the line, then edit the sixth line forward from the same
            display position as that from which this command was given.
  αβ6αβ;    Like αβ6α; after setting the column of interest to current column.


    The above commands work in both NORMAL and LINE-EDIT modes, as does
the following command which allows you to copy a line and then edit it.

  ⊗Q       Insert a copy of the line just above CURRENT and open it
	   for editing (i.e., enter LINE-EDIT mode in new line).

   If you are editing a line and type something that the line editor
does not understand it will usually ignore the error (after thinking
about it for a moment) but don't bank on this too heavily because it can
fail.

   If you type a legal ⊗ command (some are forbidden) when in LINE-EDIT mode
the line will be accepted as edited and the command will be carried out.
(Typing α. in LINE-EDIT mode returns to LINE-EDIT mode automatically without
writing the page because this command is illegal in LINE-EDIT mode.)

   The α<cr> command, that works to recall a line from the system buffer
in the system's monitor mode, is replaced by the ⊗Q command as described
above.


COMMANDS GIVEN WHILE IN LINE-EDIT MODE

   Many, but not all, of E's commands can be given when the user is
editing the current line in the system line editor.  The command index on
p. 3 indicates for each command whether it is legal from the line editor.
The letter "E" in the "mode" column indicates a command legal from the
line editor.

   When you activate the line editor with part of a command that might end
up returning you to the line editor without having accepted the edited
version of the line, E will redraw the line editor text while awaiting the
rest of the command.  This currently applies to the following partial
commands: ⊗X ⊗Z.  Also drawn will be a special cursor to indicate where in
the line you are giving the command from.  (The cursor is the same one
you'll see when stepping macros -- wider than the normal ones on DDs and
IIIs.)  However, if the line is longer than the screen width, the wrapped
around part of the line will not be displayed, nor will the cursor if it
is in that part.


LINE-EDITOR-ENTERING COMMANDS GIVEN FROM THE LINE EDITOR

E commands that normally cause the current line to be edited with the line
editor are legal even when given from within the line editor itself.  Most
of these commands are usually handled directly by the line editor, without
E ever seeing them.  But if such a command is generated in a way that
causes activation of the line editor, for instance, by preceded it with a
repeat argument using both CONTROL and META, then E figures out how to
carry out the command, usually including reloading the line editor with
the resultant text.  Thus the command αβ8G will type eight G's into the
line editor, and αβ8βH will insert 8 H's.

Attach and Copy commands: ⊗A ⊗C

  Modes     Command	    Meaning
  N,A,E,S   ⊗A	    Attach 1 line
  N,A,E,S   ⊗#⊗A    Attach # lines
  N,A,E     ⊗+⊗A    Attach 1 more line
  A	    ⊗-⊗A    Attach 1 less line
  N,E	    ⊗-⊗A    Attach line just above current line
  N,A,E,S   ⊗#⊗C    Copy # lines into attach buffer
  N,E	    ⊗-⊗C    Copy line just above current line
  A	    ⊗+⊗C    Copy one more line
  A	    ⊗-⊗C    Copy one less line (i.e., kill last line in attach buffer)
  A	    ⊗E	    Leave ATTACH mode by putting down all attached lines
  A	    αβK     Kill all attached lines
  A	    ⊗#αβK   Kill # lines at front of attach buffer
  A	    αβR     Replace attached lines (put them back where picked up)


   The attach (⊗A) and copy (⊗C) commands permit blocks of lines or
copies of them to be moved up and down on the page or from page to page,
or from file to file, as desired.

   The ⊗A command removes one or more contiguous lines of text from the
core image of the page and places them in a special attach buffer.  The
lines are still displayed on the screen in their original position, and
an "A" is displayed at the top of the screen to indicate that you are
now in attach mode.

   The ⊗C command makes a copy or one or more contiguous lines and
places the copied lines in the attach buffer.  An "A" is displayed at
the top of the screen, indicating that you are now in attach mode.

   Note that if more than 8 lines are attached, then only the first 4
lines and the last 3 lines are shown so that one can see a few lines
both before and following the attached lines to be certain as to their
relationship to the rest of the page.  The attached lines are marked by
vertical bars (thus |) at the left, except on Datamedias, where they are
indicated by being displayed in BOLD rather than lightface (this makes
attached blank lines somewhat hard to detect).

   The apparent position of the attached lines can be made to move up or
down on the page or from page to page with the usual CURRENT-moving
commands to prepare for a final command which will deposit the attached
lined back into the core image of the text at the indicated position.
Perhaps this can be made clearer by remarking that the CURRENT line
designation is actually attached to the line following the section of
text that has been removed (although the → does not appear).  What one
is actually doing when one appears to be moving the attached lines is to
move CURRENT around and E cleverly always displays the attach buffer on
the screen just above CURRENT, where it will in fact be put if one gives
the deposit-line command.

Basic commands.

  ⊗A     ATTACH the CURRENT line and mark it with a "|".
  ⊗3⊗A   ATTACH 3 lines starting with CURRENT and mark these with "|'s".
	 If a number greater than 8 is used, (for the 3 in the example),
	 only the first 4 and the last 3 lines are shown.  A row of dots
	 is used to indicate that some attached lines are not shown.

  ⊗E     Deposit the attached lines where displayed and Exit ATTACH
	 mode.  Note:  this command has a different meaning when one is
	 NOT in the ATTACH mode (it then means EXIT from E).  Don't
	 stutter when typing it.  Give the system time to react.
  αβR    REPLACE the attached lines in their original location and leave
	 the ATTACH mode.  This command will put down all the lines at
	 the last place where you gave any version of the ⊗A command
	 (⊗A, ⊗+⊗A, ⊗-⊗A); thus if you attached the lines from various
	 different places, this command will put them all down at the
	 last place you attached (or unattached) any lines.  However, if
	 you attached the lines by copying text with the ⊗C command (or
	 by using some other command that creates attached lines other
	 than by attaching existing lines from the page) and if you
	 haven't used any version of the ⊗A command since the ⊗C (or
	 other attached-line creating) command, then this command will
	 simply kill the attached lines.
  αβK    KILL the attached lines (they go away, but can be ⊗XUNDELETED)
	 and exit from the ATTACH mode.  Note that αK is a line editor
	 command.
  ⊗4αβK  KILL the first 4 lines in the attach buffer.

	 If you make a practice of using the CONTROL key only, when in
	 the ATTACH mode, (when it works) you will avoid the danger of
	 accidentally killing an attachment, if you mean to hit a J or
	 an L and hit a K instead.

  ⊗C     Make a COPY of the CURRENT line and ATTACH this copy.
	 If there is already something in the ATTACH buffer when this
	 command is given then the entire attachment will be deposited and
	 re-copied.  This provides a convienent method of making 
	 multiple copies of any desired portion of text.
  ⊗5⊗C   Make a COPY of 5 lines starting with CURRENT and ATTACH these.


Relative arguments.

  Relative-argument commands add or remove lines from the end of the
  attach buffer thus:

  ⊗+⊗A    Attach 1 more line beyond those already attached.
  ⊗+⊗3⊗A  Attach 3 more lines beyond those already attached.
  ⊗-⊗A    Detach 1 line from the end of those already attached.
  ⊗-⊗2⊗A  Detach 2 lines from the end of those already attached.

  ⊗+⊗C    Copy 1 more line beyond those already attached.
  ⊗+⊗4⊗C  Copy 4 more lines beyond those already attached.
  ⊗-⊗C    Delete (kill) 1 line from the end of the attached set.
  ⊗-⊗2⊗C  Delete (kill) 2 lines from the end of the attached set.

   If the apparent position of the attached lines have been moved before
these relative-argument commands are given then additions and deletions
are made in terms of the apparent new location.  This gets a bit hairy
in the case of deletions but it is a very useful device for assembling a
set of copied lines from several different places.

   Note that a single attach command is only effective to the end of the
current page, and an attachment is deposited all on the same page.

   A word of warning, a hazard is involved in using ⊗A to move lines
from page to page.  The attached lines can be lost if the system should
crash during the interval between the removal of the attached lines from
one page and the final updating of the page to which they are moved.
This hazard can be avoided by copying the lines rather than attaching
them and then going back and deleting the original copy.  This
precaution is hardly necessary for a line or two but it is a wise one
when you are moving large blocks of text.

   Moving lines from page to page takes time, so don't get impatient.

   This is a good place to comment on the RIPPLING report, that you may
have noticed in the scratch-pad lines at the bottom of the screen.  This
notice appears when a major rearrangement of the text between records
becomes necessary.  This also takes time.
LINE INSERT mode.

  Modes     Command	    Meaning
  I	    α<cr>   Leave LINE INSERT mode, stay on same line
  N,I	    αβ<cr>  Enter LINE INSERT mode and insert a blank line
  E,I	    αβ<cr>  Enter LINE INSERT mode breaking current line at cursor
  N,E	    ⊗#αβ<cr> Insert # blank lines
  N,E,I     αβ<tab> Go to end of current line and enter line insert mode
  I	    <alt>   Close line, leave LINE INSERT mode, delete line if empty
  N,I	    αβI     Enter LINE INSERT mode and insert a blank line
  E,I	    αβI     Enter LINE INSERT mode in current line (new line if at end)
  N,E,I     αβ↑     Move to end of line above and enter line insert mode
  N,E,I     αβ↓     Move to end of line below and enter line insert mode
  N,A,E,I   AUTOWRITE	Set or read autowriting threshold for line insert mode


While one can add text at the bottom of a page by simply moving the
CURRENT marker so that it points at the bottom row of asterisks (not the
dots), a special mode is used to insert lines of text at other points.
As a matter of fact it is usually better to enter this special
LINE INSERT mode if one is to type several lines even when at the end of
a page.  Users on non-displays can only enter text in LINE INSERT mode.

When in the LINE INSERT mode, typing a carriage return inserts the text
of that line into the page (in core, not on the disk yet), creates a new
blank line below, and leaves you editing the new blank line.  Each
carriage return in LINE INSERT mode thus creates a new blank line.
Various commands will get you out of LINE INSERT mode, usually keeping
the text of the last line inserted.

The only command that gets you out of line insert mode without accepting
the last line inserted is altmode, and even then the line's text will be
accepted unless the line is empty.  Typing an altmode on an empty line
while in line insert mode will restore the line to its state as of the
time you entered line insert mode.  In particular, either the line will be
deleted (e.g., if you typed <cr><altmode> while in line insert mode) or
the line's previous text will be restored (e.g., if you had entered line
insert mode on that line by typing ⊗I from within the line editor).

The fact that E is in the LINE INSERT mode is signalled by a double arrow
(↔) pointing to the current line instead of the usual right arrow (→) and
by an "I" appearing on the header line at the top of the screen.  (On
Datamedias, neither the double arrow nor the right arrow is used.  Only
the terminal's cursor marks the current line and the "I" at the top is
the only indicator of LINE INSERT mode.)


To enter the LINE INSERT mode:

 αβ<cr> Given from normal mode (not editing a line), this command enters
	LINE INSERT mode on a blank line inserted ahead of the current
	line.  Given from the middle of a line, this command will break
	the line where the command was given into two separate lines and
	leave you in line insert mode at the end of the first part.  If
	you were at the end of a line when you gave this command, you will
	enter line insert mode on a new blank line inserted just below.
	In any case, a double arrow (↔) and an "I" at the top will
	indicate that you are in LINE INSERT mode.

   αβI  This command is the same as αβ<cr> except when given from the
	line editor, in which case it enters line insert mode but leaves
	you editing that line without either breaking it in two or
	inserting a blank line.  The next carriage return will, as
	usual, insert a blank line.

   αI   This command enters line insert mode only when given at the end
	of the line editor (otherwise, this is a line editor command).
	From the end of the line editor, this command is just like αβI
	given from the same place (enters line insert mode on a blank
	line inserted below).

    I	This is the normal command for entering line insert mode on a
	non-display; the effect is exactly the same as that of αβ<cr>.

  αβ↑	Enter line insert mode at the end of the line above.  No new
	blank line is inserted by this command, but subsequently typing
	<cr> will insert a new blank line (as usual in line insert mode.)

  αβ↓	Enter line insert mode at the end of the line below.  No new
	blank line is inserted by this command, but subsequently typing
	<cr> will insert a new blank line (as usual in line insert mode.)

αβ<tab>	Enter line insert mode at the end of the current line.  No new
	blank line is inserted by this command, but subsequently typing
	<cr> will insert a new blank line (as usual in line insert mode.)


While in LINE INSERT mode:

  <cr>  Accept the line and move down, inserting another new blank line.

 α<cr>  Accept the line and leave LINE INSERT mode, staying at the same line.

 β<cr>  Insert a <cr> but stay in line insert mode.

  ⊗U    Leave LINE INSERT mode and move the arrow back to the line above
	the accepted line.

 <alt>  Leave LINE INSERT mode without moving the arrow.  If the last line
	inserted is empty, then that line will be deleted provided that it
	didn't exist when you entered line insert mode, but if it did
	already exist, then its previous text will be restored.  Typing
	<alt> on a non-empty line while in line insert mode always keeps
	the final text of that line.


AUTOWRITER FOR LINE INSERT MODE:

E can be made to automatically write out the incore text after a given
number of lines have been inserted in line insert mode; this is called
autowriting with a given threshold number of lines.  The default is NEVER
to write out the text automatically.

When autowriting is enabled, it occurs only upon a CR given in line insert
mode, and then only every N lines, where N is the current threshold.  When
autowriting occurs, a message to that effect is typed out and you are then
left still in line insert mode.  Only lines created with line insert mode
are included in the autowrite line counter, and the counter is reset to
zero whenever the page is written out (by any means) and whenever you
switch pages or ⊗XCANCEL.

Here are the commands to set and inquire about the autowrite mode status.

  ⊗#⊗XAUTOWRITE  Sets to # the threshold number of inserted lines after
		 which E will automatically write out the page.

  ⊗-⊗XAUTOWRITE  Disables autowriting (the default state).

  ⊗XAUTOWRITE or ⊗0⊗XAUTOWRITE  Reports the current status and (if
		 enabled) the threshold of the autowriter.

Handling very long lines.  ⊗XBREAK ⊗XJOIN

  Modes     Command	    Meaning
  N,A,S     BREAK	Break line(s) at given column position
  N,A,S     JOIN	Join two or more lines by deleting CRLFs


   The commands ⊗XBREAK and ⊗XJOIN can be used to manipulate, and to allow
editing of, very long lines because these commands do not change any text
in affected lines except for the deletion or insertion of CRLFs.  ⊗XBREAK
breaks long lines by inserting CRLFs where necessary, and ⊗XJOIN joins two
or more more lines together by removing CRLFs.  Each of these commands
take a numeric repeat argument which specifies how many lines are to be
affected.  If the repeat argument is negative, then the command affects
the given number of lines preceding the current line and the arrow is left
pointing to the first line affected.  Repeat arguments are limited to the
number of lines on the current page in the given direction from the arrow.
If there are any lines attached when ⊗XBREAK or ⊗XJOIN is given, then
lines from the attach buffer are broken or joined instead of lines from
the page.

   ⊗XJOIN joins the given number of lines (without introducing spaces for
the deleted CRLFs).  If no repeat argument is given, two lines are joined.

   ⊗XBREAK will break lines at any specified column position by inserting
CRLFs.  The column position may be specified by a numeric argument
following BREAK; the default BREAK column is originally 80 but any
typed-in column argument overrides this and is sticky.  Breaks occuring
within a TAB are assumed to precede the TAB, that is, the TAB goes at the
start of the text on the next line.  There is an exception to this if the
break is set at 8 or less and if a TAB occurs at the start of a line, when
the TAB will be placed on the first line.

   If ⊗XBREAK is given WITH a preceding numeric argument, then that many
lines are broken (not, however, extending beyond the end of the current
page or the attach buffer) and each line is broken as many times as
necessary to prevent any resulting line from being longer than the
specified column argument.

   If ⊗XBREAK is given WITHOUT a preceding numeric argument, then the
current line (or the first attached line) is broken AT MOST ONCE, at the
specified (or default) column position.
Search commands: ⊗F ⊗XFIND ⊗* ⊗XEXACT ⊗F<string>⊗P ⊗F<string>⊗: ⊗XSSLINE ⊗XSSPAGE

  Modes     Command	    Meaning
  N	    α<cr>   Position cursor at found string (after find)
	    <ESC>I  Terminate multi-page FIND
  N,A,E     αF	    Find string (delimiters not required)
  N,A,E     αβF     Find delimited string
  N,A,E     ⊗*	    Repeat last ⊗F or ⊗XFIND command
  N,A	    EXACT	Distinguish case of letters in searches
  N,A,E     FIND	Do a multipage search for a given string
  N,A,E     SSLINE	Set or report the search limiting line number
  N,A,E     SSPAGE	Set or report the search limiting page number


SEARCHING -- SPECIFYING THE SEARCH STRING

   The search can be for an alphameric string that is separated from
the rest of the text by non-alphameric characters or it may be for any
string regardless of its surroundings.  Note that the FIND commands
normally make no distinction between upper and lower case, but the
⊗XEXACT command can be used to force such a distinction.

   ⊗XEXACT<cr>	  Distinguish between upper and lower case in subsequent
		  FIND commands of all kinds.  FIND commands will only
		  find string occurrences whose cases exactly match
		  those given in the search string.
   ⊗-⊗XEXACT<cr>  Do not distinguish between upper and lower case in
		  subsequent FIND commands.  This is the default.
   ⊗0⊗XEXACT<cr>  Report the current condition of case-checking.

For incore text searches the commands are:

   αβFSmith<cr>   Find just plain Smith or smith but not this string in
		  in $smith, in blacksmith or in Smithsonian.  Note that
		  % and _ are accepted as alphamerics.
   αFSmith<cr>    Find smith as an isolated word or as part of a longer
		  string (in blacksmith for example).   The string will
		  be found even where not delimited by non-alphamerics.
   ⊗0⊗F		  Type out the search string used in the last incore
		  text search command (⊗F).  No search is done.

   Note that no space is used between the ⊗F and the start of the string.

The repeat arg (default 1) in a search command specifies which occurrence
to find.  A negative repeat arg specifies a reverse search, but reverse
searches are not implemented.

   ⊗3⊗Fsmith<cr>   Find the 3rd occurrence of "smith".


The following extended search commands first search the incore text and
then (if necessary) continue the search through the rest of the file.

   αβXFIND Smith<cr> Find a delimited string ("Smith" here).
   αXFIND Smith<cr>  Find the string ("Smith") regardless of surroundings.
   ⊗0⊗XFIND<cr>	     Type out the search string used in the last extended
		     search (⊗XFIND).  No search is done.

   Note that exactly one space is required between the command "FIND"
and the search string.  Commands starting with the letter ⊗X are EXTEND
commands which permit more than a single character to be used for the
command name, hence the need for the space to mark its end.  In this
case the complete command name is FIND, but, since there are, at
present, no other extended command names beginning with F, only the F
needs to be typed, as αXF Smith<cr>.

   Extended searches made in unformatted files are carried only as far
as the core directory has been extended.  To search the entire file, one
should first complete the directory by switching to the last page and
then switch back to the desired starting page for the search.  The fact
that the directory is incomplete is evidenced by the use of the "?"  in
the trailer line, in lieu of the usual number, to show the total page
count (thus, "Page 13 of ?").


   The delimited find command (αβF or αβXF) will not find an occurrence
of the search string that starts in column 1 of the current line, but
the non-delimited command (αF or αXF) will find such an occurrence.

   A string, once specified, is sticky; that is, one need not retype the
search string for a repeat of the command.  The search string for an
incore text search (⊗F command) is remembered independently from that
for an extended search (⊗XFIND).  For a repeat one repeats the command
up to the string itself and then types the desired termination (a <CR>
as shown above, or any termination listed below).

   Special repeat commands exist which simplify the repeated search.
These are easier to use than the regular repeat command, described
above, but only the last executed type of FIND can be repeated.  Two of
the more commonly used terminations are simulated by using different
control keys with the ⊗* command.

     αβ*   Find the next occurrence of the string specified by the last
	   FIND command (whether an incore text search (⊗F) or an extended
	   search (⊗XFIND)).  Move the line cursor to the found line but
	   do not enter the LINE EDITOR, that is, duplicate a normal
	   FIND command that is terminated by a <CR> only.  An argument
	   may be used (such as αβ1αβ3αβ*) to find the Nth occurrence.

     α*    Find the next occurrence of the string specified by the last
	   FIND command (whether an incore text search (⊗F) or an
	   extended search (⊗XFIND)).  Leave the line in the LINE EDITOR
	   as it would be for a normal FIND command terminated by a
	   α<CR>.  If there is something in the ATTACH buffer, this is
	   interpreted as an αβ* command.  See below for method of using
	   an argument.

     ⊗4α*  Find the fourth occurrence of the string specified by the
	   last FIND command (whether an incore text search (⊗F) or an
	   extended search (⊗XFIND)) and position the cursor under the
	   first character of the found string (as it would be for a
	   normal FIND command that is terminated by a α<CR>).  If this
	   command is given from the line editor, the argument must be
	   typed with both control keys (αβ) to force activation of the
	   line editor.

     ⊗0⊗*  Type out the search string used in the last FIND command
	   executed, and indicate whether it was an incore text search
	   (⊗F) or an extended search (⊗XFIND).  No search is done.


SPECIAL CHARACTERS IN THE SEARCH STRING

   The following special symbols may be used in the search string with
the meanings noted.  If these characters are desired as ordinary
characters in the searched-for string they must be preceeded by the
identity symbol ≡.

  Symbol		Meaning

   ¬		The character that follows must not be in the string at
		this point but any other character will be accepted.
   |		Any delimiter (not one of $_% nor a letter nor a digit).
   ∀		Any character.
   ≡		The character that follows immediately after this symbol
		is not to be treated as a special symbol but it is to be
		included as a character in the searched-for string.  Use
		this to quote any of these special characters.
   ∞		Not at present implemented, but still must be quoted.
   ⊂		Not at present implemented, but still must be quoted.


SEARCHING FOR STRINGS THAT INCLUDE <cr>

   To search for a string that contains one or more <cr>s, you must
surround the entire string with <lf>s and quote each <cr> with an
equivalence sign (≡).  Each <crlf> (carriage-return & linefeed) in the
text is considered during searches to be one character, namely a <cr> --
the <lf> is ignored.  E.g., to search for X<crlf>Y type:

	⊗F<lf>X≡<cr>Y<lf><cr>


SEARCH-STRING ENDING COMMANDS -- Normal, Search-distance, Directory, Reverse

   The action to be taken for a search is specified by the command used
to activate the search string, and there are four general possibilities,
depending on what the string-ending command is.

       (A) Most commands first allow the search to move to the line where
	   the string is found, and then the string-ending command is
	   executed normally.

       (B) Certain commands use as their repeat arg the search distance
	   (in lines) between the original line and the line where the
	   string is found (inclusive), and this type of command is
	   executed with that arg FROM THE LINE WHERE THE SEARCH STARTED.
	   Thus commands in this class are able to utilize the search as a
	   means of specifying the number of lines to operate on.  The
	   commands in this class are indicated in the index on p. 3 by an
	   "S" in the modes field.  Included among these commands are: ⊗A,
	   ⊗C, αβD, ⊗XJUST (and the other justify commands), and many
	   others that take a number of lines as a repeat argument.
	   Certain of these commands actually subtract one from the
	   resultant search distance, in order not to affect the line
	   where the string is found; this is done in order to make the
	   command do the "right" thing.  The user can experiment to find
	   out which commands these are.

       (C) Some commands used to end a search-string cause the directory
	   to be searched instead of the normal text.  If the string is
	   found in the directory, then E moves to the page on whose
	   directory line the string is found and then does some
	   command-specific action.  (See individual commands below.)

       (D) Ending a search string with ⊗U indicates that you want to do a
	   reverse search; that is, you want to search the text backwards
	   from the current line.  Unfortunately, reverse searches are not
	   implemented.


The command most commonly used to activate the search string is <cr>, which
simply causes the arrow to be moved to line where the string is found.

If the command ending the search string is another search commmand, then
the arrow will be moved to the line where the string is found and then E
will wait for you to complete the second search command.

Whenever a search is initiated from the line where the previous search
found its string, the new search will start from the position in the line
just beyond the beginning of the previously found string, so that
successive searches for the same string will find different instances of
that string.

The only line editor commands that can end a search string are αD and αI,
both of which are in class (A) above.  These line editor commands are
executed after moving into the line at the position where the string is
found.

Here are the most important search-string-ending commands and their effects:

   <cr>     Move CURRENT to the found line or report failure.

   α<cr>    Terminate, as with <cr>, but  move the cursor until it is
	    under the first character of the string.   Note that this
	    leaves E in the LINE-EDIT mode.  A second FIND command can
	    however be given and the next occurrence will be found.  If
	    a FIND command is terminated with <cr>, a α<cr> will still
	    move the cursor to the string.

   ⊗J       JUMP the line with the found string to the top of the
	    window.

   αβ<cr>   Enter the LINE INSERT mode with the ↔ at a newly inserted
	    blank line ahead of the found line.

   αP       Make the search over the directory page and then display
	    the referenced page with the line pointer at the top line.
		Note that one can give this command without having to
 		give an explicit command to go to the directory page.
		If the search fails, the arrow is not moved.

   αβP      Make the search over the directory page and then display the
	    referenced page with the line pointer at the second
	    occurrence of the referenced string on that page (the first
	    will be in the first line of the page).

   ⊗:	    Make the search over the directory page and then display
	    the referenced page with the line pointer at the line
	    which contains the referenced string as a label (namely,
	    the line where the string is followed by ":", "=" or "←").

   ⊗+αP     Just like the command without the ⊗+, except that only
   ⊗+αβP    pages after the current one are searched in the directory.
   ⊗+⊗:	    This is a very useful command when a string occurs on
	    several directory lines (i.e., on the first line of
	    several pages).

		All of the above directory searching commands point
		out when the resultant page turns out already to have
		been in core by saying "(incore page)".  This lets
		you know whether to use αN or αO to get back where
		you came from.

   ⊗A       ATTACH all lines starting with CURRENT up to and including
	    the line with the specified string.  If used with the
	    extended search command (⊗XFIND) and if the string is not
	    amoung the incore text, this command will attach text
	    starting at the top of the page on which the string is
	    found.  Attachments do not cross page boundries.

   ⊗C       COPY all lines starting with CURRENT up to and including the
	    line with the specified string.  See ⊗A above for
	    restriction with extended search command.

   αβD      DELETE all lines beginning with CURRENT up to but NOT INCLUDING
	    the line with the specified string.  See ⊗A above for
	    restriction with extended search command.  This is a very
	    dangerous command so use it with caution.  A safer command
	    sequence to use when you are unsure where the search string will
	    be found involves using the ⊗A search string terminator to
	    attach the text first (to make sure it is the right text), then
	    if necessary to attach a few more lines or unattach a few lines,
	    and finally to delete the attached text with αβK.

   ⊗\       Terminate the searched-for string and prepare to accept a
            substitution string.  The substitution string is then typed
	    in and may be terminated in any one of several ways.   For
	    details see String Substitution Commands on the next page.
	    Note that there is a special repeat command for this case so
	    do not try to use the repeat conventions that are used for
	    simple searches.

   <alt>    Abort the present command.  When <alt> ends an incore text
	    search string (⊗F), the string ahead of the <alt> is retained as
	    the new default incore text search string (unless that string is
	    empty) although no search is done.  When the <alt> ends an
	    extended command search string (⊗XFIND), the previous default
	    extended search string is retained.


ESC I TO ABORT AN EXTENDED SEARCH COMMAND OR A MULTIPLE SUBSTITUTION

   The <ESC>I command will terminate any extended search command in
progress at the end of the page currently being searched (unless the
string is found before the end of that page); <ESC>I will report the page
number where searching was interrupted.

   The <ESC>I command will also terminate any multiple substitution
(even the one-page type) after the next substitution is done; see p. 14.


SEARCH LIMITING: ⊗XSSLINE ⊗XSSPAGE

The commands ⊗XSSLINE and ⊗XSSPAGE set or report the limit line number and
limit page number for searches and substitutions.  These commands can be
used to keep searches and substitutions from going beyond a given incore
line or a given page; search limiting affects these commands:

	⊗F ⊗XFIND ⊗* ⊗\ ⊗( ⊗) ⊗XLPAREN ⊗XRPAREN

The ⊗#⊗XSSLINE command sets the search-limiting incore LINE number to the
given argument (#), and similarly ⊗#⊗XSSPAGE sets the search-limiting PAGE
number to the argument (#).  In both cases, if the argument is relative
(⊗+ or ⊗- used), then the limit is set by the command at the given
distance (lines or pages) from the current place (line or page) (but is
fixed once set by the command; that is, it is not permanently relative to
the arrow's position).  If the argument is omitted entirely, then the
corresponding type of search limiting is disabled.  A zero argument will
cause E simply to report the given search-limit.

Search-limiting stops any search (except a directory search, see below)
that encounters the given limit line or the beginning of the given limit
page; for instance, ⊗5⊗XSSPAGE will stop any search that encounters the
beginning of page 5, so page 5 will NOT be searched (but a search started
already on page 5 won't be limited).  As another example, ⊗+⊗XSSLINE will
limit any search to the current line, since it will stop any search upon
reaching the following line.  The search-limiting LINE number applies only
to incore text and is cleared when you flush all incore text (e.g., by
going to another page or by doing an ⊗XCANCEL command).  The
search-limiting PAGE number applies both to incore pagemarks and to
not-in-core pages (the latter reached only by the ⊗XFIND, ⊗XLPAREN, and
⊗XRPAREN commands); the limiting page number is cleared when you change
files.  Search limiting is always completely disabled during directory
searches (e.g., ⊗F...⊗P and ⊗F...⊗:).

Any incore limit line number set up is adjusted for text insertion and
deletion, to preserve the point in the text at which searches will stop.
Currently, however, any limit page number is NOT adjusted for page
insertion/deletion.  The two readonly variables SSLINE. and SSPAGE. are
available for macros to find out the current search limits; a negative or
zero value means the corresponding type of search limiting is disabled.
Note that the limit LINE number is counted from the beginning of ALL
incore lines, not just relative to the current page if you have more than
one page in core.

SUBSTITUTION commands: ⊗\

  Modes     Command	    Meaning
  N,E	    ⊗\	    Repeat last substitution command
	    <ESC>I  Terminate multiple substitution


String substitution commands are initiated by first giving a normal FIND
command but using one of the two special string terminating characters,
⊗\ (back-slash) or <lf> (linefeed).  This is then followed by the
substitution string which, in turn, is terminated by either a simple
carriage return (which may be preceeded by an argument, typed with
control keys) or by α<CR>.  Note, many of the otherwise acceptable Find
command terminations are not meaningful with the substitution commands
and are not allowed.

Please observe that an argument before the initial FIND command means
find the specified occurrence before making the substitution while an
argument before the final termination means make the substitution the
specified number of times starting with the initial arrow position (or
with the initially specified occurrence, if there is an initial
argument).

The prefered method for making repeated substitutions is to request an
initial single substitution and then to ask for the desired remaining
substitutions by the αβ\ command prefaced by an argument specifying the
remaining number of times the substitution is to be made.

Characters in the searched-for string that are preceeded by the special
control symbols ¬ and ≡ and all characters that are represented by the
special symbol ∀ or by the symbol | (see p. 13 for the explanation of
these symbols) are treated as any other character and are deleted and
replaced by the substitution string.  The "partial definition feature"
as implemented in SOS is not at present available.  The | symbol in the
searched-for string can not be used to replace a carriage return.

   Note:  The FIND command does not find the very first delimited
   string on the line to which the cursor is pointing (unless it is
   in fact preceeded by delimiter).  This limitation is of little
   consequence for the simple FIND but it is an annoyance if one
   wants to replace all occurrences of a symbol (or string) which
   happens to be the very first symbol (or string) on a page.  One
   can introduce an initial space into the first line or one can
   introduce an initial blank line temporarily and have the cursor
   at this line.  The space or line can then be removed after the
   substitution.

In the rest of this write-up "all occurrences" means "all except the
very first character or string on the line to which the cursor is
pointing at the time that the command is given when the search request
is for a delimited string".

Also, the remaining descriptions assume that the ⊗XEXACT command has NOT
been given.  If ⊗XEXACT has been given, then substitutions will be made
only for occurrences with the Exact case of letters given in the search
string.

Sample commands.

  αβFSTRINGαβ\"String"<CR>	Find the first occurrence of  the
		string STRING, whether typed in lower or upper
		case letters and replace it by the substitution
		string as typed, that is, enclosed in quotes and
		with the initial letter only in CAPS.  Limit the
		search to the incore text starting at the cursor
		location.

 αβFSTRING<LF>"String"<CR>	Same  as  the above  example, but
		typeable on a non-display because of the linefeed
		that is used instead of αβ\ to end the search
		string.

 αβFSTRINGαβ\"String"αβ∞<CR>	Find  all  occurrences   of   the
		string STRING, whether typed in lower or upper
		case letters and replace them by the substitution
		string as typed, that is, enclosed in quotes and
		with the initial letter only in CAPS.  Limit the
		search to the incore text starting at the cursor
		location.

⊗9αβFSTRINGαβ\"String"αβ∞<CR>	Find all occurrences of the string
		STRING, as above, but start the substitution with
		the 9th occurrence.

   αXFIND ←αβ\ <BACK ARROW> α<CR>	Find the first occurrence
		of the character ← whether among incore text or
		on a subsquent page and replace it by the string
		<BACK ARROW> (including the < and >) and with
		spaces introduced before and after these
		characters.  Leave the resulting line in the line
		editor.

The <CR> termination is the faster mode of operation in that it does not
use the the line editor and it is not subject to any effective
limitation as to the length of lines that may be handled.  This mode
does have one defect in that the substitution is completed and is not
subject to the simple <ALT> method of aborting a single line correction.
When the α<CR> termination is used the substitution is made via the line
editor and the results are left in the line editor's buffer so that the
substitution may still be aborted by the usual <ALT> command.

The usual rules apply to the specification of the searched-for string.
The substitution string may, however, contain certain delimiters (spaces
in particular) whether or not the search is for a delimited string and a
distinction is made between upper and lower case letters.  Only the
searched-for characters without delimiters are replaced.  To be
specific, if one were to replace a delimited string by a null
substitution string, the two delimiters would remain in the corrected
text.

Currently, substitution cannot be done for the CR (or LF) at the end of
any line of text.  A warning message will be isssued when you try to
make such a substitution.  Also, no substitution can be done for
pagemarks (formfeeds).

The substitution string is sticky, so that a substitution command, when
successfully executed for a single occurrence, may be repeated for the
next occurence by typing αβ\ only.  The typing of a new string for the
searched-for string destroys the record of the previously saved
substitution string and the entire request must be retyped before this
command will be honored.

A null substitution string may be used and no longer reguires
confirmation.

Extended substitutions are useful but potentially dangerous as the
substitutions made on any one page are, of course, written out onto the
disk file when ever a new page is entered.

As noted earlier, typing αβ\ after a legal substitution command will repeat
the substitution.  This command may be preceeded by an argument (with
control bits) and the substitution will be repeated the specified number of
times.  Should substitutions occur on more than one page, all substitutions
on pages earlier than the last page will have been written out (except when
all occur on the incore text, which might be several pages).

The use of the command α\ rather than αβ\ causes the altered line to be
left in the line editor with the possibility of an <ALT> abort.

Sample repeat commands.

   αβ\		Repeat the previously made substitution at the next
		occurrence of the searched-for string.

   αβ6αβ\	Repeat the substitution for the next 6 occurrences.

   α\		Repeat the substitution once but leave the results in
		the line editor buffer.

   ⊗0⊗\         Type out the search and substitute strings last used in a
		substitute command, and indicate whether it was an incore
		text substitution or an extended substitution.

The <ESC>I command will terminate any multiple substitution (even the
incore type) after the next substitution is done.
FILE-SWITCHING and text transfering commands: ⊗ε ⊗λ ⊗∃ ⊗? ⊗XPOINTER

  Modes     Command	    Meaning
  N,A	    ⊗ε	    Switch to given file in READWRITE mode
  N,A	    ⊗λ	    Switch to given file in READONLY mode
  N,A,E     ⊗∃	    Show names of files in fileswitch list
  N,A	    ⊗?	    Switch to the file E.ALS[UP,DOC]/R
  N,A	    ⊗#⊗?    Go to page # in E.ALS
  N,A	    ⊗+⊗#⊗?  Go to E.ALS, # pages beyond where last left it
  N,A	    ⊗-⊗#⊗?  Go to E.ALS, # pages before where last left it
  N,A	    POINTER	Switch to a file named in the incore text


   The file switching commands ⊗ε and ⊗λ cause E to close the current
file being edited (writing out the current page if necessary) and then
to ask for the name of another file to be edited.  That file is opened
for editing, with any ATTACH buffer maintained while switching files.
Thus you can switch back and forth, editing different files, and easily
moving or copying text from one file to another simply by attaching the
lines desired.  The ε command (ENTER) opens the new file in read-write
mode while the λ command (LOOK) opens the file in read-only mode.

   All of the usual switches may follow the filename typed with these
commands; for example, you can use /8P to go to page 8 in the new file,
/E to go to the end of the file, /N to open the new file in no-directory
mode, /C to create the file you want to switch to, etc.  See p. 20 for
more details.

   If the filename requested by ⊗ε or ⊗λ is omitted, and if one or more
switches are included, then the file assumed by the command will be the
one you were editing just prior to giving the command.  Only the same
filename is implied by this mechanism; no modes are assumed for the new
edit.  This makes switching major modes (like /N) easier; the filename
doesn't have to be retyped.  Also, this makes it easier to burp a whole
file; ⊗ε/∞F<cr> will burp the current file.

   As different files are referenced, each file is assigned a number
which can be used thereafter as an argument to the ε or λ command to
call the desired file without retyping its name.  Also, a stack is kept
of the files you have been in recently and you can return to a file that
is a particular distance down in the stack.  See p. 34 for the file
stack manipulation command ⊗H.  Whenever you return to a file, any
previously existing line marks and the top part of that file's page
stack are restored.

   The names of up to eight different files edited are remembered by E.
When you try to edit a 9th file, the file at the bottom of the file
stack is forgotten to make room for the new file's name.  The user is
warned of this replacement.

   The list of files with their referencing numbers is typed out by the
command ⊗∃.  The command ⊗0αH types out the file stack.

   Finally it is possible to reference the E-manual file, E.ALS[UP,DOC],
by typing the ⊗? command.  The first reference to this manual will be to
page 2 which contains information on recently made changes to E.
Thereafter the manual file is opened at the last referenced page and
line.  One may, however, override these default values by typing an
absolute or relative argument to specify the absolute or relative number
of the page to go to.

   E is smart enough to detect most cases when one tries to format a
binary file or an XGP file and it will tell you this and give you
another chance to say No.

⊗ε<file name><cr>   Close the current file  and open the specified
        file in read-write mode.   The usual switches /#P, /#L and
        /C may be used.The new file is assigned a serial number by
	which it  may  be  called later.   (The  initial  file  is
	numbered  0).   When  called  by  number  the  display  is
	returned to the last referenced page and with the arrow on
	the last referenced line and all previously set line marks
	restored.

⊗3⊗ε    Reopen the file assigned the serial mumber 3 in read-write
        mode.  Note that no carriage return is used in this case.
	Return the display to the last referenced page.  Return the
	arrow to the last referenced line and restore all previous
	line marks.  (Use the ⊗∃ command, below, to find numbers).

⊗λ<file name><cr>  Close the current  file and open  the specified
        file in read-only  mode.  The  usual switches /#P  and /#L
        may be used.   The new file is assigned a serial number by
        which it  may  be  called  later.   (The  initial  file is
        numbered 0).

αβ3⊗λ   Reopen the file assigned the serial mumber 3 in  read-only
	mode.

⊗∃      List the previously referenced files with their serial
	numbers.  For convenience the letter H accompanies the number
	in the listing of the "HOME" file and a "]" is used rather
	than a ")" for the file currently being edited.

⊗XZFILES<cr>  Move the current-file listing to location zero and clear
	the remainder of the filelist.  Clear the file stack.

αH      Return (Home) to the last referenced file.  The E-manual
	file is never considered a home file.

⊗?      Close the current file and open the E manual file
	E.ALS[UP,DOC] on page 2, (for changes) or, if it has been
	referenced earlier, to the last referenced page and line.
	page and line.

⊗1⊗?    Close the current file and open the E manual file
	E.ALS[UP,DOC] on page 1, the directory page.

⊗8⊗?    Close the current file and open the E manual file
	E.ALS[UP,DOC] on page 8.

⊗-⊗2⊗?  Close the current  file and open the E manual file
	E.ALS[UP,DOC] at 2 pages before the previously referenced
	page.

SWITCHING TO A FILE NAMED IN THE TEXT:

The ⊗XPOINTER command is used to switch to a file whose name is found in
the text of the page you are editing, at or below the current line.
With an argument of zero, the command ⊗0⊗XPOINTER will merely move to
the line containing the filename found (if any) and type out the
filename, but will not switch files.  The command with no argument moves
the arrow to the line containing the filename found (if any) before
attempting to switch files.

Furthermore, a numeric argument can be given to the ⊗XPOINTER command to
have it find the nth filename in the text; thus it is possible to switch
to any of several files all named on a given line.  An arg of the form ⊗#
will make E merely type out the #th filename, without moving the arrow and
without switching files.  An arg of the form ⊗+⊗# means switch to the #th
file named in the text; this is conveniently done right after the ⊗# form
has verified that the filename found was the one you wanted to switch to.
Since ⊗# doesn't normally move the arrow (so that you can then say ⊗+⊗#
without having changed the significance of the number), an arg of the form
⊗-⊗# finds the #th filename and moves the arrow to that line but doesn't
switch files.

Summary of meanings of ⊗XPOINTER args:

  Arg	Meaning

 (none)	Switch to first file named in the text at or below current line.
   ⊗0	Type out the first filename in the text, and move to its line.
  ⊗-⊗#	Type out the #th filename in the text, and move to its line.
   ⊗#	Type out the #th filename in the text (without moving).
  ⊗+⊗#	Switch to the #th file named in the text.


A filename in the text will not be recognized unless it is preceded by a
space, a tab, a double quote ("), or an at-sign (@) or occurs at the
beginning of a line.  Furthermore, to be accepted by this command, a
filename must have at least one of these:  (1) an explicit (non-null)
extension, (2) an explicit (complete) PPN, (3) one or more switches, or
(4) a valid filehack.  Spaces are permitted only as leading spaces in PPNs
for blank characters in the project or programmer name, and a filename
with its switches must occur all on one line.  Finally, a filename of less
than four characters (like "A.I" or "F/X") will not be recognized by E
unless it contains a filehack (which can be any length).  Thus the
following filenames will be recognized:

FILE/-R, FILE.E, FILE[J,G], FILE.EXT[J,G](R9P7L), FILE.[ J, G], \GRIPES.

The following will NOT be accepted: FILE., FILE[X], FILE/6PR, F[ ABC,D].
The only characters permitted in names within the filename are letters
(case of letters is ignored), digits, and the underbar character (which
represents a quoted space).  In particular, the down-arrow construction,
the partial-sign name, and the question-mark name are not permitted in
filenames.

Any switches following a filename in the text will be observed in
switching to that file.  In addition, any text following the extended
command name will be appended to the filename after any switches found in
the text.  Thus additional (or overriding) switches can be specified, or
if no PPN or switches appear in the text, an explicit PPN can be added.
(If the text says READ NOTICE/231P, you can use ⊗XPOINTER/D to get the
READ facility into a switch.)  Switches in the text must be perfectly
well-formed or the filename they are applied to will not be recognized.
This means that parentheses must be balanced and no letter or digit can
immediately follow the letter of a slash-type switch.  However, the
actual letters of switches are not checked for validity (as indeed they
never are by E -- undefined switches are completely ignored).

This command's default mode for switching to a file is readonly (/R).
However, this can be overriden with an explicit /-R occurring among the
switches in the text or typed in the command line after the extended
command name (e.g., ⊗XPOINTER /-R<cr>).

When you attempt to switch files with this command, if the file named in
the text cannot be edited because it does not exist, is busy, etc., E will
abort the fileswitching operation automatically (nevertheless having
written out the current page before attempting to switch files).  If,
however, the combined (text and command line) filename with switches has
an illegal syntax, E will say so and then load your line editor (on
displays) with the combined text so that you can correct it and try again.

Justification: ⊗XJFILL ⊗XJUST ⊗XJGET ⊗XSJFILL ⊗XSJUST
    (See p. 17 for ⊗XTJUST ⊗XTJFILL ⊗XTABLE and ⊗XTJGET)
    (See p. 18 for ⊗XALIGN, ⊗XINDENT, ⊗XJCENTER)

  Modes     Command	    Meaning
  N,A,S     JFILL	Justify paragraphs w/out aligning right margin
  N,A,S     JGET	Get justification margins from text
  N,A,S     JUST	Justify paragraphs and align at right margin
  N,A,S     SJFILL	Separate text into justified sentences
  N,A,S     SJUST	Separate into justified right-aligned sentences



TEXT JUSTIFICATION

E has several justification commands.  The basic commands are ⊗XJFILL
and ⊗XJUST -- the former fills lines as much as possible without
inserting extra spaces, and the latter justifies the right margin by
inserting extra spaces where needed.  The commands ⊗XSJFILL and ⊗XSJUST
are similar but make each Sentence start on a new line.  The command
⊗XJGET is useful for setting up the margins from already-justified text
on the page.  These commands (JFILL, JUST, SJFILL, SJUST, JGET) all use
the same set of margins.  The commands ⊗XTJFILL, ⊗XTJUST and ⊗XTJGET can
do the same things as the same commands without the leading "T" in the
name, but the "T" commands use a different set of margins (so you can
have two sets of margins in effect at a given time) and they are
designed to handle a special form of paragraph -- one that has zero or
more "Tab fields" preceding the text in the first line of each
paragraph.  The "T" commands can align these tab fields and
simultaneously justify the remaining text of each paragraph.  The "T"
commands are described on p. 17.

The range of application of any justification command may be limited by
a prefixed decimal argument.  If no argument is specified, the command
affects the entire page.  If there is an attachment, the command works
on the ATTACH buffer instead of the page.  When the range is limited by
a positive argument, the command starts with the arrow line and goes
forward whereas for a negative argument the command works on the
specified number of lines before (but not including) the arrow line.

There is no effective limit to the length of lines or the margins that
can be handled by the justication commands.

If you're not sure what a justification command will do, you should
execute the ⊗. command to write out the page before the justification so
that you can undo any undesired effect with the ⊗XCANCEL command.


BASIC JUSTIFYING COMMANDS: ⊗XJFILL and ⊗XJUST

The line filling command ⊗XJFILL adjusts the lengths of lines by moving
words from line to line as required to achieve the specified maximum line
length (right margin).  At the same time this command permits the left
margin to be fixed at any desired position with a separate settable
indentation for the first line of each paragraph (crown margin), and it
allows one either to preserve blank lines or to specify the desired number
of blank lines preceding each paragraph (blanklines margin).  The ⊗XJUST
command does the same things as the ⊗XJFILL command but also justifies the
right margin by distributing additional spaces between words.  Both of
these commands put two spaces after each sentence, where the end of a
sentence is indicated by one of the characters .?!: followed by either two
spaces or the end of the line, optionally with any of the characters >]}")
occurring between the .?!: and the spaces or end of line.


SETTING THE MARGINS

The margins can be changed by giving a justification command and
following the command name with a space and then the desired new
margins, separated by commas.  The margins are always given in the
same order, namely, Crown, Left, Right, Blanklines.  Any margin that
is not being changed can be omitted but its comma must appear if any
subsequent margins are being specified.  Any margins set remain in
force until explicitly changed.  The meanings of the various margins
are explained below.

  The Crown margin is the indentation used for the first line (crown
  line) of each paragraph.

  The Left margin is the indentation used for all non-crown lines.

  The Right margin is the maximum length of a line, including any
  indentation.

  The Blanklines margin is the number of blank lines desired ahead of
  each paragraph -- setting this margin to -1 will cause E to
  preserve exactly the number of blank lines found in the text.

The margins are initially set to 0,0,74,-1 (C,L,R,B).  This means that
the crown margin (paragraph indent) is 0, the left margin (non-crown
indent) is 0, the rightmost character is not to go beyond column 74, and
the distribution of blank lines is to be the same in the resulting text
as found in the original text.

To find out the current margins, use an argument of zero with a
justification command, for example ⊗0⊗XJFILL<cr>.  A zero argument is
also useful for setting the margins without doing any justification.


DETECTING PARAGRAPHS IN INPUT TEXT

A simple procedure is used to determine where paragraph breaks occur in
the input text being justified.  For justification purposes, a new
paragraph is indicated by (1) an empty line or (2) a line indented
exactly the right amount (that is, a line having the right number of
leading blank columns, whether tabs or spaces or both are used to make
the indentation).

The amount of indentation that indicates a paragraph in the input text
will be called the DETECT-PARAGRAPH margin, or simply the DETECT margin.
Note: If you haven't set the detect margin explicitly (see below), and
if the crown margin and the left margin are the same, then only blank
lines will indicate new paragraphs in the input text (otherwise every
line would become a separate paragraph).

The detect margin is normally the same as the crown margin.  However,
for changing the crown margin of justified text that has no blank lines
between paragraphs, the detect margin can be set explicitly to any
value.  Furthermore, it may be necessary to set the detect margin to
some non-occurring value (e.g., 99) to prevent paragraph detection from
occurring on lines that are already indented by the amount that you want
paragraphs to be indented (that is, the (new) crown margin).  For
instance, when changing from 0,0,74 to 0,8,74 you'll need to set the
detect margin to a non-zero value (e.g, use 99/0,8,74).

The detect margin can be set in any justification command by
typing its value immediately after the extended command name and
following it with a slash ("/").  After the slash, the normal margins
(crown, left, right, blanklines) can be specified, separated by commas.
For instance, the command ⊗XJUST 8/7<cr> would set the detect margin to
8 (for paragraphs indented with one tab or eight spaces) and then would
rejustify the text so that each paragraph was indented only 7 spaces.
Note that the detect margin remains in effect until you change either
the crown margin, the left margin, or the detect margin itself.  Thus
after the above command, E would no longer recognize the new crown lines
(now indented 7 spaces) as such since the detect margin would still be
8.  The detect margin can be set without changing any of the other
margins, as in ⊗XJUST 7/<cr>.  The command ⊗XJUST 8<cr> explicitly sets
the crown margin to 8 and implicitly also sets the detect margin to the
same value (8).


SEPARATING SENTENCES WITHIN PARAGRAPHS: ⊗XSJFILL and ⊗XSJUST

The task of rearranging sentences within a paragraph or of moving
sentences from one paragraph to another is simplified by the use of the
⊗XSJFILL and ⊗XSJUST commands.  These commands separate all sentences in
the specified text so that each sentence starts on a different line.  The
first sentence in each paragraph will be indented by the crown margin and
all other sentences will be indented by the left margin.  Within each
sentence, the text is justified exactly as it would be by the ⊗XJFILL and
⊗XJUST commands.  These commands accept new margins following the command
name just like the other justification commands.

The end of a sentence is indicated by one of the characters .?!: followed
by either two spaces or the end of the line, optionally with any of the
characters >]}") occurring between the .?!: and the spaces or end of line.


FIGURING OUT JUSTIFICATION MARGINS FROM TEXT ON THE PAGE: ⊗XJGET

The ⊗XJGET command causes E to scan a specified section of text and to
determine the indents of crown lines and non-crown lines and the column
position of the rightmost character.  This command sets these values
into the crown margin, left margin and right margin for subsequent use
by the ⊗XJUST, ⊗XJFILL, ⊗XSJUST and ⊗XSJFILL commands.  ⊗XJGET normally
sets the blank-line parameter to its initial default value of -1 (which
means that all blank lines encountered during justification will be
preserved and no new blank lines will be generated).  However, any
margins given explicitly in the ⊗XJGET command will override the
corresponding margins determined from the text.  This command types out
the resultant settings of the margins.

By using this command one can redetermine the parameters that were used
when the text was justified, presumably at some earlier editing session
or perhaps by someone else and one can do this without having to make
the determination by visual inspection.

Here is the algorithm used by E to determine the margins from the text.
First, the length (in columns, not characters) of the longest line in
the range becomes the right margin.  Second, the text is scanned to find
the first blank line.  If a blank line is found, then the next non-blank
line is assumed to be a crown line and its indent is stored as the crown
margin; the indent of the following line is stored as the left margin.
If no blank lines are found within the specified text, then the indents
of the first two lines are compared.  If these two indents are not the
same, the first is taken as the crown margin and the second as the left
margin.  If the first two line indents are the same, these lines are
taken to be non-crown lines and the rest of the text is scanned for the
first line with a different indent; if one is found its indent becomes
the crown margin and the next line's indent becomes the left margin.  If
all lines in the range have the same indentation, then that indentation
becomes both the crown margin and the left margin.  The practical effect
of all of this is that one should not execute a ⊗XJGET command starting
with a line that is the last line of a paragraph (but even that is ok if
a blank line follows).


SOME TYPICAL JUSTIFICATION COMMANDS:

⊗XJUST<cr>     	Justify the current page (or the ATTACH buffer if in
		ATTACH mode) using the current margins.  The right
		margin will be justified.

⊗XJU 0,4,66,0<cr>  Justify the current page or the ATTACH buffer using
		the new margins given.  The crown lines will all have a
		0 indent, the left indent for the rest of the text will
		be 4, the last occupied column will be 66, and there are
		to be no blank lines between paragraphs.

⊗XJFILL 8/10,10,,1<cr>  Justify (left margin only) the current page,
		which has been previously edited so that each paragraph
		starts with 8 spaces (or a tab).  Note that this command
		calls for the indents of all lines (crown and non-crown)
		to become the same (10) and that paragraphs are now to
		be separated by single blank lines.  The right margin is
		unchanged since no new value was given for it.

⊗0⊗XJF ,,72<cr>  Change the right margin to 72 and then type out the
		margins, including the detect margin if applicable.

⊗XJGET 4<cr>    Set the margins to those found by examining the entire
		incore text, then set the crown margin to 4, and finally
		type out the new margins.

⊗!⊗XJG<cr>	Set the margins to those found by examining the current
		set of contiguous non-empty lines (⊗! command).  This is
		a very useful command to execute before rejustifying an
		edited paragraph.  However, the ⊗! command is only
		useful for this if you have blank lines between
		paragraphs.  Also, the ⊗! command is not useful as an
		argument to justify commands when you have text
		attached, since the ⊗! command always counts lines on
		the page itself, never in the attach buffer.

⊗6⊗XJG<cr>	Set the margins to those found in the 6 lines starting
		at the arrow (or at the beginning of the attach buffer,
		if any).

⊗!⊗XSJFILL<cr>	Separate the sentences in the current set of contiguous
		non-empty lines (⊗! command).
Commands for tabular material: ⊗XTABLE ⊗XTJFILL ⊗XTJUST ⊗XTJGET ⊗XTGET
	(See p. 16 for basic justification information and other commands.)

  Modes     Command	    Meaning
  N,A,S     TABLE	Line up entries in a table
  N,A,S     TGET	Same as TJGET command (see below)
  N,A,S     TJFILL	Justify paragraphs that begin with a table
  N,A,S     TJGET	Get margins for TJFILL/TJUST from text
  N,A,S     TJUST	Justify & R-align paragraphs beginning w/table


    Four new commands have  been added that permit  one to handle  tabular
material in a manner analogous to way in which normal text can be treated.

    Two types of commands are provided to take care of the two classes  of
input data that are most apt to be encountered, these being:

A)  Tabular material that is in proper columnar alignment but that may have
    missing entries.

    The ⊗XTABLE command is intended for use with such material.

B)  Tabular material that  may not  be in proper  columnar alignment,  but
    where the  entries are  separated by  at least  2 spaces  or by  TABs.
    There may also be normal text associated with each tabular line  which
    is to be justified.  Of course, in  this case there can be no  missing
    entries.

    The ⊗XTJFILL and ⊗XTJUST commands  are intended  for use  under  these
conditions.

   These new Tabular commands require the specification of additional
values in addition to the C,L,R,B values specified with the ⊗XJUST and
⊗XJFILL commands.  Of course, just as for these older commands, default
values may be used and only those values that are to be changed need to
be specified.  Margins are specified as usual.

   When new tabular-field values are to be typed, these must start with
a semicolon ";" and they are to be separated by commas.  Values not
otherwise marked are taken to be field lengths, that is the string
;5,8,9<CR> is taken to mean that there are to be three columns the first
one starting with an indent as specified by the P value and with a field
length of 5 character positions, this is to be followed by a second
field of 8 character positions, then one with a field length of 9.
These values supercede the field lengths that had previously been
specified for the first three fields and if still additional fields had
been specified these are to be retained and shifted to the right or left
as may be required because of the changes to the first three fields.

   When specifying changes in fields, it is only necessary to type
numbers for those fields that are to be changed and to indicate
preceding fields by commas.  Fields after those typed are retained
unless the typed-in string is followed by the letter Z (for zero).
Should there be more fields specified for output than are specified for
input, E warns the user at the time of execution of the TABLE or TJ
command and ignores the extra fields; should there be fewer output
fields than input fields, the command is aborted.

   When several fields are to have the same length these fields may be
specified by the use of the @ sign, thus 9@5,7 means that there are to
be 9 fields of length 5 followed by a field of length 7.  Fields to the
left of a field that is to be changed may be indicated that are to be
left the skipped by the use of commas without numbers, thus ,,7 means
leave the first two columns unchanged and make the next one with a
length of 7.  Similarly 4@0,3@5 means leave the first 4 columns
unchanged and make the next 3 columns with lengths of 5.  Note that
zero, in this case, does not mean a column of zero length but means no
change.

   Fields must have widths of 3 or more to permit a single character and
to allow for there to be two spaces between the characters in different
columns.  Should any particular entry be too long for the width
specified, the next entry is automatically moved to the right so as to
preserve the desired separation between columns.  Such excesses may
propagate.

   A fourth command ⊗XTJGET has been provided to perform the same
function for tabular material that is performed for ordinary text by the
⊗XJGET command.  It should be noted that this command must determine the
positions of each column as well as the left margins and so it must be
given when the designated text is restricted to start with a tabular
line in which there are no missing entries.

Note: The ⊗XTGET command does the same thing as ⊗XTJGET.
	

The specifications for these new tabular commands will be listed below.


⊗XTABLE 

This command must be given either 1) after a prior execution of the
⊗XTJGET command, 2) with the entire set of tab fields specified, or 3)
after some combination of commands satisfying 1 or 2.  In effect, one
must provide E with information as to the existing state of the input
textual material since there does not exist any "Normal" set of
conditions that can be assumed.  While, in principle, it is possible to
provide this information by typing it in, it is thought that this task
can best be handled by E with ⊗XTJGET.

   Information regarding the desired new format must also be provided
and this will usually be done by typing the needed information as a
suffixed string as described below.  This information is sticky and it
need not be retyped.  If there exists a sample of tabular material that
is already in the desired format even this second task may be left to E
by again using the ⊗XTJGET command as explained below.  Note that the
⊗XTJGET command changes the parameters as they relate to the conditions
to be established.

   This command will accept a prefix argument defining the number of
lines to be processed and a series of suffixed arguments similar in
every respect to the syntax used with ⊗XFILL and ⊗XJUST.  One enters
information as to the desired tabular fields by then typing a semicolon
";" followed by a series of decimal numbers which define the field
lengths to be used.  If several fields are to be all the same length the
syntax, 5@7 for example, may be used meaning in this case that there are
to be 5 fields of 7 characters positions each.  Alternately it is
possible to define a field in terms of the last colmnar position that it
is to occupy by prefacing the number with an exclamation mark "!".  Note
that it is not possible to specify the starting column as this is set by
the cumulative lengths of the preceding fields.

   For example, the command αβ7αβXTAble 4;10,6@5,!60<CR> would specify
that there be 8 fields with the first one occupying 10 columns starting
at an indent of 4 then there are to be 6 fields each occuping 7 columns
and a final field ending at column 60.  The starting indent for this
last field is obtainable by adding up the columns already accounted for
(44) and so the last field is to be 16 columns wide.  Note that it is
only necessary to type a single number before the semicolon as this
commands starts all lines with the crown or new paragraph indent.  The
normal left margin indent is not used and the program automatically
determines the right margin value from the accumulated column count.

   This command requires information as to the existing format of the
data to be reformatted and information as to the desired new format.
The new format information can then be typed in with the ⊗XTABLE command
or it my also be obtained from an existing table (or portion of a table)
that is already in the desired format by using the ⊗XTJGET command.


⊗XTJFILL and ⊗XTJUST

   As mentioned earlier these commands are for use with tabular data
that have no missing entries but do have with them some associated text
that one wants justified.  The listings of commands with explanations,
as used in this manual is an example of such material.  The original
material need not be aligned into columns.

   The methods for specifying the various parameters is similar in all
respects to that described for the ⊗XTABLE command.  Especial care must
be used in establishing these parameters particularly as regards the
number of fields.  The signal for a new field is taken to be the
presence of 2 or more spaces between entries (3 spaces if the entry ends
with a sentence-terminating punctuation mark) and if the textual
material has already been justified and padded there may be cases where
these conditions are met in the associated textual material.  The
program differentiates between these entirely on the basis of the number
of tabular entries that are expected and that have been found.

   CAUTION: It is unwise to use ⊗XTJUST on text that one may want to
re-⊗XTJUST or ⊗XTJFILL later, since any additional spaces at word breaks
which the first ⊗XTJUST introduces will be taken as a tabular field
indicators during the execution of the subsequent commands.


⊗XTJGET

The command ⊗XTJGET determines the margin values of a designated portion
of text in a manner similar to that used by the ⊗XJGET command, except
that in addition to the crown, left, right and blanklines margins, the
positions and widths of tab fields are also set by ⊗XTJGET.

MARGIN CONTROL commands: ⊗XALIGN ⊗XINDENT ⊗→ ⊗← ⊗XCENTER
	(See p. 16 for basic justification information and other commands.)

  Modes     Command	    Meaning
  N,A,S     ⊗←	    Shift line or attach buffer left by current indent default
  N,A,S     ⊗#⊗←    Shift # lines left by current indent default
  N,A,S     ⊗→	    Shift line or attach buffer right by current indent default
  N,A,S     ⊗#⊗→    Shift # lines right by current indent default
  N,A,S     ALIGN	Align left margins of text
  N,A,S     CENTER	Center text of given lines between margins
  N,A,S     INDENT	Indent lines by given amount


   These commands preserve the identity of the text lines while
preforming certain operations on their left margins.

   ⊗XALIGN moves all lines defined by the location of the arrow line and
a prefixed argument (with 1 line or the entire ATTACH buffer as the
default option) so that all lines start with a specified (or default)
indentation.  The command uses initial TABs to the extent possible.  The
command can take a single suffixed decimal (sticky) argument to specify
the desired indentation.  The initial default value is set at 0.

   The command ⊗XALIGN may be set to operate in one of two different
modes with respect to the treatmant of interior TABs.  The initial
default mode is for all interior TABs to be replaced by the equivalent
number of spaces that they produced before the alignment was effected.
The other mode is entered by typing the letter T (for TAB) as a suffixed
letter (after the command name and separated from it by a space).  This
mode leaves all interior TABs untouched.  The mode as so changed is
sticky and applies for all subsequent ALIGN and INDENT commands.  The
initial default mode may be restored by typing the letter S (for
Spaces) in an ALIGN or INDENT command.

   INDENT simply moves the specified number of lines (default is 1 line
except that in ATTACH mode the default is the entire ATTACH BUFFER) to the
right or left by the specified amount independent of their original
starting positions.  This permits blocks of code to be moved right or left
while preserving their original relative indentations.  INDENT will takes
one suffixed numerical argument specifying the desired indentation, (a
positive number if to the right or a negative number if to the left).
Motion to the left is limited by the edge of the page but there is no
practical limit to the motion to the right so take care when changing the
indent value.  The initial default indent value is 4.  See the above
paragraph for the handling of interior tabs by the INDENT and ALIGN
commands.

   The commands ⊗→ and ⊗← are special cases of INDENT.  They move the
specified lines to the right or left by the (absolute) amount that had
been set previously by the ⊗XINDENT command.  The default number of
lines is one if not in ATTACH mode or it is the entire ATTACH buffer,
and the initial default indentation is 4.  Unlike ⊗XINDENT, these arrow
commands do not require a ⊗X or a carriage return.  Like ⊗XINDENT they
limit the text motion to the left edge of the page.  These commands do
not take suffixed arguments.


Typical commands.

⊗XALIGN<cr>     ALIGN the  earrow  line (or  entire  ATTACH buffer  if  in
		ATTACH mode)  with  all  lines moved  to  start  with  the
		default ALIGN indentation (originally set to 0).

⊗4⊗XALIGN 5<cr>  ALIGN 4 lines starting with  the arrow line (or with  the
		start of the ATTACH buffer if in ATTACH mode) so that they
		are indented by 5.

⊗XINDENT<cr>    INDENT the arrow line (or  the entire ATTACH buffer if  in
		the  ATTACH  mode)  by  the   default  value  (set  to   4
		initially), but do not let any line move far enough to the
		left to lose any non-space characters.

⊗8⊗XINDENT 3<cr>  INDENT 8 lines starting with CURRENT by 3, that is, move
		the 8 lines  to the  right by  8 positions,  with the  new
		default value being set to 3.

⊗6⊗XIND T 3<cr>  INDENT 6 lines, starting with the arrow line, by 3  after
		changing the mode so that interior TABs are kept as TABs.

⊗6⊗XINDENT -3<cr>  INDENT 6 lines  starting with CURRENT  by -3, (that  is
		move them to the left by 3 positions).


⊗→              Move the CURRENT line or the ATTACH buffer contents to the
		right by the previously established amount.

⊗←              Move the CURRENT line or the ATTACH buffer contents to the
		left by the previously established amount.

⊗6⊗→            Move 6 lines starting  with the CURRENT  line or with  the
		start of the ATTACH buffer to the right by the  previously
		established amount.

   ⊗XCENTER centers all lines defined by the location of the arrow line
and a prefixed argument (with 1 line or the entire ATTACH buffer as the
default option) so that all lines are individually centered between the
left and right margins as previously specified for the ⊗XJUST or ⊗XJFILL
commands, or desired values may be typed with the center command itself
and these new values will then be the default values for the ⊗XJUST and
⊗XJFILL commands.  See these other commands for full details.

   The command uses initial TABs to the extent possible.  Interior TABs
are replaced by spaces before the centering is effected.
Other EXTENDED commands: ⊗X<cmd> ⊗Xα<cr>

  Modes     Command	    Meaning
  N,A,E     ⊗X	    Enter eXtended command next
  N,A,E     ⊗Xα<cr> Load line editor with previous extended cmd line to retry
  N,A	    AL		Change your job's ALIAS
  N,A	    ALIAS	Change your job's ALIAS
  N,A,E     AUTOBURP	Set or read autoburping threshold
  N,A,E     BEEPME	Beep the user's terminal now
  N,A	    BLOAT	Add extra records of nulls to current page
  N,A	    BURP	Burp current page of extraneous records of nulls
  N,A,E     CHECK	Enable free storage checking within E
  N,A	    CLOSE	Close the file, but allow further editing
  N,A	    CORCHK	Try to core down if possible (done automatically)
  N,A,E     DDTGO	Call RAID, if available (ERAID only)
  N,A	    DPYALWAYS	Update the display after every command
  N,A	    DPYSKIP	Only update the display when no typeahead
  N,A,E     ECHO	Turn on/off echoing of text edited in line editor
  N,A,E     EMPTY	Move to next empty line on page
  N,A	    LINCNT	Type length of current line, plus more info
  N,A,S     MAIL	Mail a message to someone
  N,A,E     NONEMPTY	Move to next non-empty line on page
  N,A	    OPEN	Open the current file in Read-Alter mode
  N,A	    PPSET	Ensure that the page printer is positioned ok
  N,A	    PROTECTION	Set or read the protection key of the file
  N,A,E     QUIT	Exit to monitor without writing out the file
  N,A	    READONLY	Disallow changing the file
  N,A	    READWRITE	Allow changing the file
  N,A,S     REMIND	Enter a REMIND-system reminder
  N,A	    SAVE	Write out incore page(s) in E$SAVE.TXT
  N,A,S     SEND	Send a message to someone logged in
  N,A,S     SIN		Replace tabs with equivalent numbers of spaces
  N,A,S     SPOOLC	Spool incore page(s) on the line printer
  N,A,E     TELLME	Report the latest commands to person maintaining E
  N,A,E     TERSE	Enter terse mode--suppresses some typed info
  N,A,S     TIN		Replace multiple spaces with equivalent tabs
  N,A,E     TMPCOR	Write out (now and on exit) TMPCOR file used by E
  N,A,E     VERBOSE	Enter verbose mode--types out extra info
  N,A,E     WRITTEN	Type out who previous wrote the file and when
  N,A,S     XSPOOL	Spool incore page(s) on the XGP


   Certain commands are either potentially too dangerous to be safely
evoked by a single character or too rarely used to waste a
single-character command on.  There are also more commands than can be
obtained with single characters.  These contingencies are handled by the
EXTEND command specified as follows:

   ⊗X       Execute the following extended command, which starts with
	    the command name and normally ends with a <cr>.  The
	    command name may be abbreviated as long as no ambiguity
	    results.  The command name must be terminated by a space
	    if parameters follow it, or by a <cr> or some other
	    activating character.

   ⊗Xα<cr>  Load the line editor (displays only) with the last ⊗X command
	    line typed (whether valid or nor), to let you edit it and try
	    again.  The α and β bits that you get on the edited command
	    are precisely what you type on the X in ⊗Xα<cr>; also any
	    numeric arg typed to the ⊗Xα<cr> is applied to the edited
	    command.  This command is a no-op when executed inside a macro
	    or on a non-display.

Some EXTENDED commands (usually ended with carriage return):

   ⊗XALIAS <project>,<programmer>
       or
   ⊗XAL <project>,<programmer>
		This command can be used to change your alias PPN.  It
		takes a following text argument in exactly the same form
		as the system ALIAS command:  1) PRJ to set project to PRJ
		and programmer to logged in name, 2) PRJ, to set project
		to PRJ and retain previous alias programmer name, and 3)
		PRJ,PRG to set both project and programmer.  Note that
		this command cannot be abbreviated beyond ALIA.  This
		command types out your new ALIAS on both the current piece
		of paper and PP 0 so that you will see your changed alias
		when you exit.

   ⊗XAUTOBURP   This command can be used to set or read the threshold
		number of records of nulls for autoburping.  If no numeric
		arg is given, E will simply type out the current threshold.
		A positive arg to this command sets the threshold to that
		many records.  A zero or negative arg disables autoburping
		entirely.  An arg of just "+" sets the threshold to its
		default value, which is currently 19.  While autoburping is
		disabled, the header line will display "/-A" after the
		filename.  (A page to be written out that has the threshold
		number of records of nulls, or more, will be automatically
		burped to delete all records of nulls from that page.)

   ⊗XBEEPME     Beep me now.  This may be typed ahead whenever desired and
		you will be beeped when this command is reached.

   ⊗#⊗XBLOAT	Write out the current page with at least # records of nulls
		to provide space for text to be added later.  This command
		is useful if you are preparing to add a lot of text to a
		page and you don't want E to have to ripple every time you
		need one more record for the page's text.  If you have the
		last page of the file in core, then this command will not
		write out any extra records of nulls since they aren't
		needed to avoid rippling.  If you have more than one page
		in core, the extra space is allocated to the last incore
		page.  This command disables autoburping if # exceeds the
		current autoburp threshold, in order to avoid having the
		new bloatedness autoburped away in the near future.

   ⊗XBURP       Write out the current page and in the process reduce the
		disk space for that page to a minimum by deleting any
		all-null records from the current page.

   ⊗XCHECK      Enable checking of free storage (currently the default);
		⊗-⊗XCHECK disables free storage checking; ⊗0⊗XCHECK
		reports the current condition of free storage checking.
		Macros which are to be executed many times (e.g., 100 or
		more) will often be executed significantly faster if free
		storage checking has been disabled.  It is recommended,
		however, that free storage checking normally be left
		enabled (except when you are repeatedly executing a macro)
		because internal E errors are detected much faster that
		way, with less chance for clobberage of your file.

   ⊗XCLOSE      Close the file.  This allows others to read it if you had
		modified it.

   ⊗XCORCHK     Make E try to core down if possible.  There may be
		certain situations where E doesn't automatically core
		down as much as possible immediately, but this
		command will force it to core down if appropriate.
		Users NEVER REALLY NEED to use this command.

   ⊗XDDT        Branch to RAID if it is present.  αP returns.

   ⊗XECHO       Turn ON the echoing of text edited in the line editor
		(displays only); this is the default mode.  The command
		⊗-⊗XECHO turns OFF echoing of text edited in the line
		editor, but causes the activator of such edited text to be
		typed out so that you can tell what it is (although this
		typeout will occur late since it is done by E, not the
		system).  The command ⊗0⊗XECHO reports the current state
		of echoing.

   ⊗XFIND       Do a search or substitution; see p. 13 for details.

   ⊗XGORPG      Exit from E and repeat the last RPG command.

   ⊗XJUST       Justify the current page (or the ATTACH buffer if in ATTACH
		mode) using the default values for the paragraph, left and
		right margins.  Margins are initially set to 1,1,69.  For
		elaborations on this basic command, see p. 16.

   ⊗XLINCNT     Type out (1) the number of the current line, (2) the
		number of lines on the current page, (3) the number of
		columns in the current line, (4) the number of characters
		on the page, (5) the current page number, and (6) the
		number of lines attached, if any.

   ⊗XMAIL <destinations and switches>
     or
   ⊗XSEND <destinations and switches>
     or
   ⊗XREMIND <destinations and switches>
		Execute a system MAIL, SEND or REMIND command using text
		from the current page or attach buffer.  If a numeric arg
		is given with any of these commands, only that many lines
		of text are included in the message.  Leading blank lines
		are excluded from the text given to MAIL (in order to make
		the ⊗! command useful for specifying the range of text).
		If a zero arg is used, a one-line message can be sent
		entirely from the ⊗X-command line (no text from page or
		attach buffer sent).  For example, ⊗0⊗XSEND ME Hey, it
		really works!<cr> will send ME the message "Hey, it really
		works!"  You can also use the command line to include a
		subject or an initial text line ahead of the message text
		being output from the page (or attach buffer).  That is,
		⊗!⊗XMAIL/SUBJECT PRG Sending mail from E<cr> will mail the
		current paragraph to PRG with the subject "Sending mail
		from E".

		These commands are executed by starting up another job
		running the MAIL program.  When that job finishes, it will
		type out a message on your terminal reporting the success
		or failure of the command.  Detailed information on
		failure is not given.

		When there are no job slots for E to start up a MAIL job,
		mail sent from E is queued (by writing it into a special
		file on RMD,SYS which will get processed later
		automatically).  You are told when this is happening, and
		you will eventually be notified of the success or failure
		of the mail delivery.

		Also, whenever the MAIL program detects an error in mail
		coming from E, it will mail the whole message and command
		back to the sender with an appropriate message prefixed to
		it.

		See Appendix 4 in the Monitor Command Manual for full
		details on the form of switches and destinations for these
		commands.

   ⊗XOPEN       Open the current file in Read-Alter (RA) mode (not legal
		in Readonly mode).  You should only use this command if
		you intend to make some change to the current file, since
		such opening of the file in RA mode will update the
		date/time written to the present.  THIS COMMAND IS NEVER
		NEEDED -- E will open the file in RA mode automatically
		when you first try to write out a page -- but ⊗XOPEN is
		useful if you intend to make some changes to a file and
		you want to make sure that when you actually do write out
		a page, no one reading the file will cause you to get the
		ENTER FAILED message that leaves you talking to the
		monitor with only two alternatives:  CONTINUE to try again
		and REENTER to write out the incore text in your
		E$SAVE.TXT file.  Note, however, that the ⊗XOPEN command
		has no failure return -- if it can't open the file, this
		command itself generates the same ENTER FAILED message and
		the program stops and waits for you to type CONTINUE (or
		REENTER).

   ⊗XPROTECTION  Type out the protection key for the file being edited.

   ⊗XPROTECTION nnn  Change the protection of the file being edited to the
		octal value nnn.  Only 3 octal numbers may be given.  An
		attempt to change the protection of a file that is
		protection protected againt the user will not work.

   ⊗XREADONLY   Inhibit any further writing of the file.  You can leave
		readonly mode with the ⊗XREADWRITE command (if the file is
		formatted).  If you try to write out a changed page while
		you are in readonly mode in a formatted file, E will
		demand that you respecify the mode (readonly or readwrite)
		that you want.  If you choose readwrite, the changed page
		will be written out.

   ⊗XREADWRITE  Enable writing (modifying) the file.  The file must be
		formatted for this command to work.  However, if you are
		editing a one-page unformatted file, this command will
		still work by changing you to /N mode (no directory on the
		disk).

   ⊗XXSPOOL
     and
   ⊗XSPOOL      These commands spool on the line printer and XGP,
		respectively, the current page, or the ATTACH buffer if
		something is attached, without writing it out in the
		current disk file.  If a numeric arg is given for either
		of these commands, only that many lines of text are
		spooled (they are spooled from the attach buffer if
		anything is attached).  This allows you to spool a copy of
		changes that you have made whether or not you intend to
		incorporate them into the disk copy of the file that is
		being edited.  The spooled copy carries the same header
		information as it would have carried had it been spooled
		in the usual way.  For spooling on the XGP (⊗XXSPOOL
		command), the default font and page margins are used.

   ⊗XSIN        Put Spaces IN, in place of TABS, for example, so that the
		actual spacings will be preserved when extra characters
		are added ahead of TABs.  This command may take a prefixed
		argument specifying the number of lines to be operated on.
		Without an argument it is applied to the entire page or to
		the entire ATTACH buffer.

		This command will, of course, increase the space occupied
		by the text on the disk.  The inverse command, ⊗XTIN,
		should be used to replace spaces by TABs, and then, this
		should be followed by an ⊗XBURP before saving the page.
		Note that TIN will not restore previous tabs that took up
		only one space.

		SINning without TINning and BUrping is bad.

   ⊗XTIN        Put Tabs IN, in place of spaces, when this will result in
		a net saving in the space occupied by the text on the
		disk.  Extra spaces and/or TABs at the end of lines are
		also deleted.  No change is made in the way the text is
		displayed.  This command may take a prefixed argument, to
		specify the number of lines to be processed.  Without an
		argument it is applied to the entire page or the ATTACH
		buffer.  The inverse command is ⊗XSIN; however, SIN will
		not restore tabs and spaces at the ends of lines.

		While this command reduces the number of spaces used in
		the text, it does not necessarily reduce the space that
		the text will occupy on the disk.  The command ⊗XBURP
		should be used after the ⊗XTIN command, for this purpose.

   monitor command REENTER
     or
   ⊗XSAVE       Write out the current incore page(s) and any attach buffer
		in the file E$SAVE.TXT on your LOGIN disk area.  This is
		done automatically for almost all fatal errors detected by
		E; when it happens as a result of such an error, a message
		to that effect is typed out.  (The file E$SAVE.TXT may NOT
		be written out successfully if the error is detected again
		while writing this file.)  Note that any previous
		E$SAVE.TXT file is superseded (replaced) by the new file.
		Note also that this command (and its automatic call upon
		error detection) does NOT touch the file you currently
		have open for editing.  Whenever the E$SAVE.TXT file is
		written, E's TMPCOR file is also written so that the
		monitor command ET<cr> will get you back to that point.

   ⊗XTELLME     Make a standard "E error report" to report the last
		several commands executed and some internal E data.
		This command should only be used if you think you have
		just seen a bug occur in E.  This command provides
		valuable information for tracking down possible bugs.
		If you use this command, you should shortly afterward
		mail a message to the E maintainers (BUG-E) explaining
		what sort of bug you think you just saw.

   ⊗XTMPCOR     Write out the TMPCOR file now to remember the current
		state of the edit stacks.  Also, this also causes the
		TMPCOR file to be written out whenever you subsequently
		leave a file, as if you had given as standard E monitor
		command originally.  This is sometimes useful to remember
		your place if you did something funny originally that
		normally inhibits use of the TMPCOR file (like, saying "R
		E;<file>" instead of "ETV file").  See the description of
		what goes in the TMPCOR file on p. 20.

   ⊗XWRITTEN    Type out the date and time at which the current file was
		previously written and the PPN and jobname of the person
		who did it.  This information is saved even after you have
		modified the file, that is, even after the system has lost
		this data; however, once you switch away from a file this
		data is lost for that file.

   ⊗XTERSE
     and
   ⊗XVERBOSE    E can be in any one of three possible report states.  The
		reporting state determines how much information E types
		out a various times.  The three states are:  (1) the
		normal default state, (2) a verbose state achieved by the
		command ⊗XVERBOSE and (3) a terse state achieved by the
		command ⊗XTERSE.  The normal state can be restored by
		giving either ⊗-⊗XVERBOSE or ⊗-⊗XTERSE.  You can find out
		the current state by giving either ⊗0⊗XVERBOSE or
		⊗0⊗XTERSE.  The normal state now does somewhat less
		reporting (that is, less typeout) than formerly.  No error
		messages are ever suppressed by the terse state.

		The following remarks are currently suppressed only in the
		Terse state.

		    Only one MARK and you are there!
		    There are no marks!
		    Already marked!
		    Not marked!
		    All marks have been cleared.
		    Removing last MARK on this page.
		    MARKS on this page only have been cleared.
		    Page is empty.  (⊗XNDFAIL, ⊗XNDSAIL cmds)
		    Aborting macro ... (error occurred in macro)
		    Abort of # macros requested from ... (⊗#⊗XABORT cmd given)
		    No lines broken (⊗XBREAK command).
		    Free storage checking is now disabled/enabled. (⊗XCHECK)
		    Deleted text saved up to nnnn chars.  (⊗-⊗#⊗XUNDELETE)

		The following remarks are typed out only in the Verbose
		state.

		    N characters added/removed (justify commands)
		    Line now has N chars. (join)
		    You have replaced XXX with YYY (substitute)
		    (detailed info of the parenthesis commands)
		    The new line of N chars lists M items (⊗XNDFAIL/SAIL commands)
		    Calling ... (calling a macro)
		    Ending ... (a macro has finished)

   ⊗XNONEMPTY
     and
   ⊗XEMPTY      Move to the next empty or non-empty line.  A repeat
		argument will cause these commands to look for that many
		empty or non-empty lines.  A negative arg will cause the
		search to go backwards.  A positive arg (or default of 1)
		will ignore the current line and search from the next
		line, but will not cross a subsequent incore pagemark;
		hence the search is of only one page.  These commands can
		also be used, both inside and outside macros, to tell if
		the current line is empty--use a zero arg:  ⊗0⊗XEMPTY is a
		no-op if the current line is empty, but will say something
		and stop any running macro if the current line is
		non-empty; ⊗0⊗XNONEMPTY is a no-op if the current line is
		non-empty, but will say something and stop any running
		macro if the current line is empty.


   ⊗XDPYALWAYS	Always re-display text after each command.

   ⊗XDPYSKIP    Don't re-display text if there are typed-ahead commands to
		be executed.  (normal mode)

   ⊗XPPSET      Reset screen position of page printer (the three lines at
		the bottom of the screen which echo commands).

   ⊗XQUIT	Exit WITHOUT writing out to the disk any text changes.
		All other commands that exit write out any changes first.
System commands and file SWITCHES.

(See also "Filenames, numeric extensions, and filehacks" on p. 31.)

   There are five main monitor commands available that run E in
various modes (for the first file edited).  These monitor commands
are: ETV, EREAD, CETV, READ and BOOK.  All of these commands restore
(upon startup) the list of the last few files you have edited along
with related information about each file.  When you exit from E, this
information is saved in a TMPCOR file (see details below) for later
restoration.  The meanings of these monitor commands are as follows.

ETV	Edit a file normally.

EREAD	Edit a file in readonly mode.  An E command is available to
	change from readonly mode to readwrite mode.  In readonly mode
	you cannot change the file.  See the /R switch later.

CETV	Create a new file with one empty text page and begin editing it.
	See also the /C switch.  If no filename occurs with this command,
	then the result is the same as if you had said ETV, not CETV.

READ	Read a documentation file.  This command will attempt to find
	the file on one of several system documentation disk areas and
	will then edit it in readonly mode.  See also the /D switch.

BOOK	Read a book file.  This command provides for keeping your place
	in the book over long periods of time (while you read it) but
	always edits the book in readonly mode without letting you
	change to readwrite mode.  See also the /B switch.

   Any of these monitor commands can be followed by zero, one, or
more filenames.  If no filename is given, then E edits the last file
previously edited.  If one filename is given, that file is edited.
Two filenames can be given to have E copy one file to another and
then edit either file; a left- or right-arrow is placed between the
filenames to indicate which file is to be copied, with the first file
listed always being the one edited.  Additional filenames can follow
the initial one (or two), preceded by commas -- such filenames
indicate files to be placed on E's file stack for editing later; this
mechanism is mainly used by E itself to remember the last few files
edited but is also available to the user for entering several
filenames.

   Any filename can be followed by switches that tell E the mode(s) in
which to edit the given file.  Also, if the first filename is omitted,
switches can still be inserted where that filename would be; such
switches apply to the last file previously edited (which will be edited
again).  The available switches are explained later.

   One more monitor command can be used to run E.  This one is different
from those listed above in that the use of it suppresses the normally
automatic remembering of the names of files edited.

R E;	Run E but don't restore information about previous files edited
	and don't remember information about current files edited.
	This command has little usefulness, especially since E normally
	remembers not just the last one, but the last three files you
	have edited.  Note that the filename(s) must be preceded by a
	semicolon.


	     THE TMPCOR FILE -- SAVING AND RESTORING YOUR
		 EDITING STACKS, LINE MARKS, AND MODES

   If you run E normally (by using any of the monitor commands listed
above except "R"), then when you exit, E saves information about the files
you have been editing.  (Actually, the information is saved each time you
leave a file, not just when you exit.)  When you return to E with one of
the same monitor commands, this information is restored.  The information
is remembered in a TMPCOR file (a temporary file in system core that goes
away when you log out).  When you leave a file, E remembers the names (and
stack positions) of the top three files in your file stack, and for each
file remembered, E also remembers the following: (1) the top part of the
page stack (including the final page, line and window position), (2) all
line marks, and (3) the current modes, including the settings of the /R,
/N and /F switches.  If auto burping is disabled, this fact is also
remembered in the TMPCOR file; note that the state of auto burping is
global to all files edited.

   When you return to E with one of the standard E monitor commands,
the TMPCOR file is read and the information there is stored by E
internally so that if you edit any of the same files again, the stacks,
line marks and modes for that file are restored to their previous
values.  For example, when you give the "ETV<cr>" monitor command with
no filename, E will edit the last file you were in and restore the
saved information for that file; in particular, E will start up editing
the file at the same page and line where you were when you left that
file.  Also, if you return to E with the monitor command "ETV
<filename><cr>", and if the file named was remembered in the TMPCOR
file, then the saved information for that file will be restored.  In
either of these example cases, other remembered files will have their
corresponding data saved, and the files will automatically be entered
in E's file stack; switching to such a file will cause the saved
information about that file to be restored.

  Whenever you edit a file by explicitly giving that file's name
(with or without an explicit filename extension), the state of the /R
flag is determined by the command you gave rather than by the previous
state of this flag.  If you edit a file without giving its name
explicitly, the /R flag is restored to its previous value unless the
command itself specifies a particular state for the /R flag (e.g.,
both the ⊗λ command and the EREAD monitor command specify /R).


SWITCHES

   A switch consists of an optional decimal number followed by a single
letter, all either preceded by a slash or enclosed in parentheses.  Any
number of switches may follow the filename that the switches are to
modify.  The infinity character "∞" may be used as the decimal number
for a switch, as in /∞F; "∞" represents a large positive value.  Using
a number of 0 in any switch is exactly equivalent to omitting the
number completely.  Some switches actually take two decimal numbers,
separated by a comma -- for example, /3,5M.  In such cases, if the
second number and the comma are omitted, zero is used for the second
number (which is usually a line number).

   Here are a couple of equivalent commands.

		ET E.ALS/R/7P/2L		ET E.ALS(R7P2L)

Switches are NOT ALLOWED in front of a filename.  "ET /R FOO" is illegal.

The available switches are listed below.  The inverse of any switch
can be specified by inserting a minus sign "-" between the slash
and the letter, as in /-R.  This is useful when you want to override
a positive switch default.

Note that if two switches specify conflicting conditions, the latter
switch overrides the switch occurring earlier.

	/C	Create a new file with the specified name.  This is of
                  most use when one wishes to create a new file with
                  the file switching command ⊗ε, perhaps to hold some
                  attached text from the current file.
	/R	Open the file in the read-only mode.  This is useful
 		  if one wants to examine a file without any danger
		  of inadvertently modifying it.  For example:
			ETV TEACH.TXT[UP,DOC]/R<cr>
                  You can leave read-only mode by using the ⊗XREADWRITE
                  command.  You enter read-only mode with ⊗XREADONLY.
	/B	Book mode.  Edit the file in book mode.  In this mode
                  you are never permitted to alter the file nor are you
                  permitted to leave this mode.  See the explanation of
                  book mode on p. 29.
	/N	No Directory.  Edit the file without writing a directory
                  on page one.  The directory must be generated from
                  scratch and the file reformatted each time you edit
                  the file.  The directory is kept in core by E but
                  never written in the file.
	/F      Repage and reformat the file with the maximum page size
		  limited to the default value of 33 (one screenful on
		  Data Disc terminals).  The F may be preceeded by a
		  decimal argument to use any desired number instead of
		  33.  Old page marks are retained, so it is not
		  possible to increase the page size by this switch and
		  some pages may be shorter than the specified length.
		  This switch is particularly useful for getting long
		  unformatted files into a shape where they can be
		  handled safely and easily.  Also, when this switch is
		  used with an argument of infinity ("∞"), the effect
		  will simply be to reformat the file, during which
		  process E "burps" the file by removing unneeded nulls
		  (except from the directory page).
	/F/R    (This is a combination of two switches.)  Repage and
		  reformat the core version only without changing the
		  disk copy.  The new directory will be on page 0 and
		  the old directory (if there is one) will be kept as a
		  part of the text starting on page 1.  Do not try to
		  use the old directory as it is invalid.  This switch
		  combination is particularly useful for examining
		  (without altering) unformatted files that have been
		  produced by programs other than E.
	/nX     Reformat the file and bloat each page (except the
		  directory and the last page) by # records of nulls
		  (after discarding previous records of nulls (except on
		  the directory page)).  This switch also disables auto
		  burping.  Thus this switch is useful when you are
		  about to perform a large amount of editing which might
		  have otherwise caused rippling several times.  If the
		  number n is omitted (i.e., "/X"), then the default
		  bloat amount is used, which is currently 3 (records).
		  The bloat amount is limited to prevent the resulting
		  file from becoming bigger than 256K or more than twice
		  its previous size; however, since this switch can
		  still make a file very big, care should be taken to
		  avoid wasting disk space unnecessarily.  Note that you
		  can unbloat (i.e., burp) a file with /∞F.
	/nA     Set the auto burp threshold to n records of nulls.  If n
		  is omitted, auto burping is enabled with the default
		  threshold.  The switch /-A disables auto burping.  The
		  effect of this switch is global; i.e., it applies to
		  all files edited until changed by another /nA switch or
		  by the ⊗XAUTOBURP command (which see).  While auto
		  burping is disabled, the header line will display "/-A"
		  following the filename.
	/nP	Open the file at page n, where n is a decimal number.
        /mL     Open the file with the arrow at line m (m is decimal).
	/x,yZ	Open the file at page x and line y.
	/E	Open the file at the End of the last page.
	/nE	Open the file at the End of page n (decimal).
	/S      Open the file at the Same page and line the last file
		  was open at.
	/nW     Open the file with the window initially positioned so
		  that line n of the initial page is at the top of the
		  screen.  This does not affect the initial setting of
		  the arrow line, which has priority over this switch.
		  Therefore E will not obey the /nW switch if it
		  conflicts with the starting line number.
	/Q      Quietly assume a Yes answer to any questions E would
		  otherwise ask about formatting or replacing an
		  existing file or about discarding any invalid or
		  undesired directory.
	/x,yM	Place a line-mark on page x at line y.  Note that this
		  switch takes two decimal arguments separated by a
		  comma.  See the line marking commands on p. 8.  This
		  switch is a no-op when switching to the ? file or to a
		  file that you have already been in because previous
		  line marks in such a file are restored automatically.
	/x,yO	Push the position consisting of page x and line y on
		  the page stack for this file.  This switch also is a
		  no-op when switching to the ? file or to a file that
		  you have already been in because the previous page
		  stack in such a file is restored automatically.
	/D      Search the system documentation disk areas for the file
		  specified and then edit in Readonly mode whatever file
		  was found.  Thus you don't need to specify either the
		  extension or the PPN of documentation files.  If no
		  extension is given, then files with extensions other
		  than UPD will be found before UPD files.  However, any
		  explicit extension, project, or PPN given will be
		  observed.  If an extension is given but no PPN, E will
		  look for the particular file on any of the
		  documentation areas.  If a project is given, say PRJ,
		  then E will look for the file on [PRJ,DOC].  If a
		  programmer name is given, then no searching of
		  documentation areas will be done and normal PPN
		  scanning applies and the /D will merely force the file
		  to be edited in Readonly mode.  The monitor command
		  READ runs E and implies /D.  Here are some examples of
		  the monitor command READ and the /D switch.
      READ UUO        Edits the UUO Manual file in readonly mode.
      READ UUO.UPD    Edits the update file for the UUO Manual in readonly mode.
      ⊗εMONCOM/D      Switches to the Monitor Command Manual in readonly mode.
      READ NOTICE/E   Edits the NEWS program's text file of notices in readonly
		      mode, starting at the End.
	/-U     Suppress updating the directory whenever possible.  In
		  particular, this switch is the DEFAULT when you are
		  editing SOMEONE ELSE'S MESSAGE FILE (on 2,2 -- this
		  default does NOT apply to MSG.MSG files, but an explicit
		  /-U will work on such files).  Thus if you go edit a
		  message that you sent someone, your edit will not screw
		  up his "place" in the file because E will retain the
		  non-updated directory for him.
		The maintaining of the owner's "place" (last previously
		  existing page) in the file works under virtually all
		  conditions of editing a file in /-U mode, even if it
		  ripples or if you burp it -- however, autoburping is
		  never done while in /-U mode.  Although the /-U switch
		  is not displayed to the user, its presence will be noted
		  (on displays) when you write out a page -- the "U" flag
		  on the header line will appear (or not disappear if it
		  was already there) if the incore version of the
		  directory didn't get completely written on the disk.
		One particular effect of /-U mode is that changing the
		  first line of a page will not force the directory to be
		  written out (although it will still cause the "D" to
		  appear in the header, and when the page is written out a
		  "U" will appear in place of the "D"); thus the directory
		  can become inconsistent with the TEXT of the first line
		  of each page (and if you leave such a file without doing
		  an ⊗XUPDATE and come back to that file later, E won't
		  know that the directory does not reflect the actual
		  first line of each page).  However, the record numbers
		  on the directory page are NOT allowed to become invalid
		  or inconsistent.  As usual, the ⊗XUPDATE command will
		  write out the directory (if necessary to update the disk
		  version), and in addition, this command will take you
		  out of /-U mode.
		The default /-U mode that occurs when editing another
		  person's message file cannot be overriden with the /U
		  switch; you must actually give the ⊗XUPDATE command to
		  leave /-U mode, but YOU SHOULDN'T DO ⊗XUPDATE WHILE IN
		  SOMEONE ELSE'S FILE.  (The /U switch has no use except
		  to override an earlier /-U switch in the same command
		  line!)


NEED TO REFORMAT FILE, or WOULD YOU SETTLE FOR /R MODE, or FOR /N MODE?

   If you try to edit, in readwrite mode, a file that does not have a
valid E directory, E will tell you that the file needs to be reformatted
and will ask if that is ok.  If you say Yes (just Y), then E will format
the file and add a directory page at the beginning of the file.  If you
say No (just N), E will give you some alternatives.  These include
editing the file in readonly mode (/R) (for which E does not need a
formatted file) and editing the file in no-directory mode (/N) (for
which E will have to format the file so that each page begins on a
record boundary, but no directory page will be written at the beginning
of the file).  If you say No to each of the alternatives, E will ask for
a new filename.  If you type <altmode> in place of Y or N for any
alternative, E will forego the remaining alternatives and immediately
let you give a new filename.

   To any of the Yes or No questions about formatting, you can respond
/R to tell E to edit the file in Readonly mode, or you can respond /N to
tell E to edit the file in No-directory mode.  Like the normal responses
(Y or N), the special responses /R and /N do NOT take a carriage return.


DIRECTORY ERRORS DETECTED WHILE EDITING A FILE

If E detects any inconsistency between a file's directory and the location
of individual pages in the file, an error message will be typed out.  If
the user is in /R mode, he will be allowed to continue reading the file
(but will not be permitted to change it).  If the file is not being edited
in Readonly mode, then the directory error will cause E to stop (with its
usual saving of incore text in E$SAVE.TXT).  Directory errors SHOULD never
occur, unless perhaps the file has been messed up with some program other
than E or unless there is some problem with the disk.

Using E from a non-display (TTY).  XTYPE XNUMBERS XHEADER XTRAILER XCONTROL XMETACONTROL

  Modes     Command	    Meaning
  N,A,E     CONTROL	Make next cmd char have only the CONTROL bit
  N,A	    ENTER	Switch to given file in READWRITE mode
  N,A	    EPSILON	Switch to given file in READWRITE mode
  N,A,E     EXIST	Type out fileswitch list
  N,A	    HEADER	Type out the header line (from top of window)
  N,A	    LAMBDA	Switch to given file in READONLY mode
  N,A	    LOOKUP	Switch to given file in READONLY mode
  N,A,E     METACONTROL Make next cmd char have both META and CONTROL bits
  N,A,E     MSG		Operate on current message with next command
  N,A,E     NUMBERS	Enable or disable typing of line numbers with text
  N,A,E     PARTIAL	Operate on current message with next command
  N,A	    TRAILER	Type out the trailer line (from bottom of window)
  N,A,S     TYPE	Type out line(s) of text


It is possible to use E from a non-display terminal.  Of course, some of
the advantages of E over, say, SOS are lost but one may not want to go
to the trouble of having to switch editors in mid-stream.  As partial
compensation for the lack of display features, E provides the
non-display user with optional line numbers.  See the MONITOR COMMAND
MANUAL sections 3 and 4.7 for other information of interest to
non-display users.

No special action is required of the non-display user to tell E that
a non-display is being used.  E figures that out automatically.

An important and useful command on non-displays is ⊗XTYPE, which
types out a number of lines.

  ⊗#⊗XTYPE<cr>	Types # lines starting at CURRENT and moves CURRENT
		past those lines.  If # is omitted, 10 lines are
		typed if on a non-display terminal, but only 1 line
		is typed if on a display terminal (useful for seeing
		long lines that go beyond right edge of display).

The following command can be used to enable or disable the typing
of a line number and tab at the start of each text line typed out.

  ⊗XNUMBERS<cr> E lets you select whether or not you want line numbers
		typed out.  The command ⊗XNUMBERS enables typing out
		line numbers and the command ⊗-⊗XNUMBERS disables
		typing line numbers.  In ⊗-⊗XNUMBERS mode on a
		non-display, when you go into line insert mode, E types
		out a once-only prompt and tells you the line number of
		the first line you are about to insert.  The current
		initial default is ⊗-⊗XNUMBERS (no line numbers).  The
		command ⊗0⊗XNUMBERS restores the line numbers mode to
		its initial default (currently ⊗-⊗XNUMBERS).

Here are some arguments for using each mode:

XNUMBERS:  In this mode you always know where you are on a page; and
	   when you are in line insert mode, you get a prompt (of the
	   line number) to remind you that you are inserting text.
	   Blank lines are obvious because of the leading line number,
	   unlike in -XNUMBERS mode where a blank line of text typed out
	   may go unnoticed.

-XNUMBERS: In this mode, typeout of lines is a little faster, since the
	   leading line number and tab are omitted.  Also, the resultant
	   typeout of each line is 8 spaces shorter, thus making fewer
	   long lines wraparound on each given-width terminal.
	   Furthermore, in line insert mode, a one-time prompt tells you
	   at what line number on the page you begin inserting text, and
	   the text that you insert is flush with the left margin.  Thus
	   a ↑U (clear input line) command to the monitor (which puts
	   you back at the left margin on the next line) leaves you
	   still properly lined up with text from previous lines.

The ⊗XTRAILER and ⊗XHEADER commands type out the header and trailer lines,
respectively, which normally delimit the window of text shown on display
terminals.  These commands are useful on non-displays for getting some of
the information that is not otherwise obtainable, such as the record and
character counts at the end of the trailer line and the mode letters at
the end of the header line.  These lines contain dots (...) when there are
more lines beyond the current window in the given direction and stars
(***) when the window includes the last line in the given direction.  Note
that the line number (if any) typed out by ⊗XHEADER is the line number of
the first line in the window, NOT the line number of the current line.
The ⊗XTRAILER command types the number of the current ("arrow") line.


TYPING COMMANDS FROM NON-DISPLAYS:

Initially, each character typed to E from a non-display is assumed
to be a command; that is, the character is read by E as if it had
been typed with the CONTROL key depressed.  One can, however, enter
LINE INSERT mode by typing the character I and then everything
thereafter is accepted as text to be inserted until ALTMODE (ESC on
some terminals) is typed.  Of course, when the non-display user
types the command character X, E waits for an extended command
name to be typed followed by a carriage return.

The LINE EDITOR is not available on non-displays, so it is not
possible to arbitrarily edit an existing line on a non-display.
However, it is possible to use the substitution commands (using the
linefeed delimiter at the end of the search string) to change part
of one or more lines.  Also, the ⊗XBREAK and ⊗XJOIN commands can be
used to separate out part of a line that you want to change.

The following two extended commands allow the user on a non-display
to execute commands that require precisely just the CONTROL bit or
precisely both the CONTROL and META bits.  These are prefix commands
which affect the following command.

 ⊗XMETACONTROL  This causes the next character to be interpreted
		as if it had both the META and CONTROL bits.
		This is useful on a non-display when you want to
		use a command that requires both META and CONTROL.

 ⊗XCONTROL      This causes the next character to be interpreted
		as if it had the CONTROL bit but NOT the META bit.

If neither of the above two commands is used on a non-display, a
command that makes a distinction between CONTROL and META-CONTROL
will execute the CONTROL version; and a command that distinguishes
between any bits and none at all will execute the no-bit version.

The control key on a non-display is not at all the same as the
Stanford-keyboard CONTROL key referenced in most of this manual.

Some characters cannot be typed from a non-display to a user program
(like E) because their use has been preempted by the system.  Thus
it is impossible to input those characters as text in E.  However,
where such characters are used as commands by E, there is an
alternative extended command that does exactly the same thing as the
single-character command which the system intercepts.  The table
below lists these extended commands and the single-character
commands they represent.  For details on what these extended
commands do, see the writeups in this manual for the corresponding
single-character commands.

Extended	Equivalent Single-Character Command
Command

⊗XEXIST		⊗∃ (there-exists sign, octal 025, ↑U (intercepted by system))
		   Types out file-switch list.
⊗XPARTIAL	⊗∂ (partial-sign, octal 017, ↑O (intercepted by system))
		   Carries out next command on current message.
⊗XMSG		⊗∂ (partial-sign, octal 017, ↑O (intercepted by system))
		   Carries out next command on current message.
⊗XLAMBDA	⊗λ (lambda, octal 010, ↑H) Switches files.
⊗XLOOKUP	⊗λ (lambda, octal 010, ↑H) Switches files.
⊗XEPSILON	⊗ε (epsilon, octal 006, ↑F) Switches files.
⊗XENTER		⊗ε (epsilon, octal 006, ↑F) Switches files.

Stanford characters that cannot be sent as text or as E control
characters are:

Octal	Usual		Prints	Typed	Preempted as a system
	name		out as	in as	  command used for

002	alpha		α	<ctr>B	type-out pause (toggles)
003	beta		β	<ctr>C	monitor call
017	delta		∂	<ctr>O	flush type-out (toggles)
025	there exists	∃	<ctr>U  clear input line
032	tilde		~	<ctr>Z  end of file
033	not equal	≠	<ctr>[  altmode


Character equivalences, Stanford AI Lab character set:

Code	Name		Prints	Typed	Preempted
octal			out as	in as	for

000	null
001	down arrow	↓	<ctr>A
002	alpha		α	<ctr>B	type-out pause (toggles)
003	beta		β	<ctr>C	monitor call
004	logical and	∧	<ctr>D
005	logical not	¬	<ctr>E
006	epsilon		ε	<ctr>F
007	pi		π	<ctr>G

010	lambda		λ	<ctr>H
011	TAB
012	LF
013	VT
014	FF
015	CR
016	infinity	∞	<ctr>N
017	delta		∂	<ctr>O	flush type-out (toggles)

020	containment	⊂	<ctr>P
021	implication	⊃	<ctr>Q
022	intersection	∩	<ctr>R
023	union		∪	<ctr>S
024	for all		∀	<ctr>T
025	there exists	∃	<ctr>U  clear input line
026	circle times	⊗	<ctr>V
027	double-arrow	↔	<ctr>W

030	underbar	_	<ctr>X
031	right-arrow	→	<ctr>Y
032	tilde		~	<ctr>Z  end of file
033	not equal	≠	<ctr>[  altmode
034	less or equal	≤	<ctr>\
035	greater or eq	≥	<ctr>]
036	equivalence	≡	<ctr>↑
037	logical or	∨	<ctr>←

040	SP
041	exclamation	!	!
042	double quote	"	"
043	number sign	#	#
044	dollar sign	$	$
045	percent		%	%
046	ampersand	&	&
047	close s. quote	'	'

050	left paren	(	(
051	right paren	)	)
052	asterisk	*	*
053	plus		+	+
054	comma		,	,
055	minus		-	-
056	point		.	.
057	slash		/	/

060	digits		0	0
...
071			9	9
072	colon		:	:
073	semicolon	;	;
074	left broket	<	<
075	equal		=	=
076	right broket	>	>
077	question mark	?	?

100	at sign		@	@
101	upper-case	A	A
...
132			Z	Z
133	left bracket	[	[
134	back slash	\	\
135	right bracket	]	]
136	up¬arrow	↑	↑
137	left-arrow	←	←

140	open s. quote	`	`
141	lower case 	a	a
...
172			z	z
173	left brace	{	{
174	vertical bar	|	|
175	ALT			ALT or ESC
176	right brace	}	}
177	BS or DEL		BS or DEL
PARENTHESIS finding/matching commands: ⊗( ⊗) ⊗XLPAREN ⊗XRPAREN ⊗↔ ⊗XPAREN ⊗XPINFO

  Modes     Command	    Meaning
  N,E	    ⊗(	    Find (
  N,E	    ⊗)	    Find matching )
  N,E	    ⊗↔	    Return to place ⊗(, ⊗) or ⊗↔ was given
  N,E	    LPAREN	Search for next "(", crossing page boundaries
  N,A,E     PAREN	Set the chars searched for by parenthesis cmds
  N,A,E     PINFO	Type out info about last parenthesis command
  N,E	    RPAREN	Search for next ")", crossing page boundaries


   This set of commands allows one to check nested sets of bracketing
symbols for matching pairs and for related properties.  The search may
be restricted to the current page by using the ( and ) forms or it may
be extended over the rest of the file by the extended commands ⊗XLPAREN
and ⊗XRPAREN.  It always starts from the location of the cursor at the
time the command is given and proceeds in the forward direction.  The
nesting level is re-assigned the value 0 at the cursor's current
position for each new command (see special conventions below).

   The default symbols are the normal parentheses ( and ).  An EXTEND
command ⊗XPAREN allows one to define any desired set.  The command
itself must be delimited by a space and followed by the desired two
characters and a carriage return.  If the desired pair is from the set
→←, ⊂⊃, `', ≤≥, {}, <>, [], then only the first of the set and a
carriage return should be typed.  If another set had been chosen the
default set may be reset by typing the setting command with a carriage
return only.

   Note, that a space is an acceptable symbol and for this reason extra
spaces are not permitted in the command string.  A distinction is also
made between upper and lower case characters so that both may be used.
In the special case when the same character is assigned to both symbols,
the concept of nesting has no meaning and the commands are interpreted
differently, as noted in the special section below.

   In what follows, the two symbols of the chosen set will be referred
to as the left-symbol and the right-symbol respectively.

   The normal commands are then ⊗( and ⊗).  Each of these may take an
argument which specifies the sought-for nesting level for the region
defined by the bracketing symbol.  The default argument is 1 for both
commands.  The corresponding extend commands are ⊗XLPAREN and ⊗XRPAREN.
These commands may be given both when not in the line editor and when in
the line editor.  If given when in the line editor the line will not be
written out should the search be unsuccessful or should the search be
successful with the found symbol in the same line.  A successful search
that results in leaving the line editor to go to another line will cause
the original line-editor contents to be written.

   There is one additional command ⊗↔ which, in effect, un-does the last
⊗(, ⊗), ⊗XLPAREN, ⊗XRPAREN or ⊗↔ command and returns the cursor to its
former position.

   Note that the most frequent use of these command will be in LISP
   where one wants to find matching parentheses, and hence the use
   of ( and ) for the commands and for the default symbols.

   SAIL users may find it useful to define an otherwise unused set
   of symbols to mean BEGIN and END (some people already use ⊂ and
   ⊃ for this purpose), and to use these symbols in their stead, at
   least while debugging.

Special conventions

A special convention has been adopted to avoid ambiguity for those cases
in which these commands are given while the line-editor cursor is under
one of the searched-for bracketing symbols.  This convention is that a
cursor under a left-symbol is presumed to be actually to its left, that
is, outside of the symbol (as it appears) and a cursor under a
right-symbol is presumed to be actually to its right, again outside of
the symbol (and again as it appears).

   Arguments, when used with these commands refer to the desired nesting
level within the region defined by the nesting pairs.  If no argument is
given, the default value is 1, in accordance with the usual convention
for most E commands.  As a mnemonic aid, the sought-for symbol is
reported with the argument shown after left-symbols and before
right-eymbols although the argument must always be typed before the
command (to permit the command character, itself, to be used as the
activator).

   By convention the starting level is always re-assigned the value 0.
Left-symbols increase the nesting level and right-symbols decrease the
level.

Typical commands

⊗4⊗(	Move  the  cursor  to that  left-symbol which  would  cause  the
	nesting to reach a level of 4, considering the present cursor
	position to be at level 0.  Do not move the cursor if this level
	is not found and report the deficiency.  This request is
	reported as (4 for the reasons noted above.

⊗(	With no argument, this command finds the very first left-symbol.
	If the cursor is already at a left-symbol this command is a
	NO-OP.  This is in consequence of the convention that a cursor
	under a left-symbol actually refers to the situation just ahead
	of the symbol.

⊗XLPAREN   This is the same as ⊗( except that the search is permitted to
	continue past the end of the current incore page(s).

⊗)	If the  cursor is  already positioned  under a left-symbol, move
	the cursor to the matching right-symbol.  If the cursor is not
	under a left-symbol, then search for that right-symbol that
	returns returns the nesting level to its initial value of 0.
	Should the cursor be under a right-symbol, the initial level is
	taken to be that at its right.  Note that this command is a
	NO-OP only for the case where the desired level cannot be found.
	This request is reported as 1).

   If the end of the text is reached before a transition from level 1 to
level 0 is found, the cursor is left in its original position and the
deficiency is reported along with the other data.  Deficiencies, in this
case can be of two sorts, either a level of 1 is never reached or having
been reached and possibly exceeded as a result of left-symbols, a
right-symbol is never encountered while at this level.  In the first
case, the deficiency figure is reported following a down arrow (meaning
always below).

⊗XRPAREN   This is the same as ⊗) except that the search is permitted to
	continue past the end of the current incore page(s).

⊗3⊗)	Search through the text as just described but stop at  the first
	right-symbol that reduces the nesting-level from the specified
	level, in this case 3.  This request is reported as 3).

Interpretation when the same character is used for both symbols:

   Both the ( and the ) command, in this case, ignore the symbol that is
above the cursor at the time the command is given and search for the Nth
next example of the specified symbol, where N is the argument that is
used with the command.  The ( command is not a NO-OP in this special
case.

INFORMATION ABOUT PARENTHESIS SEARCHES

In the Terse or normal reporting states, E does not type out all the
possible information when a parenthesis search is done.  To find out
all this information, use the following command, or be in Verbose
mode when the search is done.

   ⊗XPINFO	Type out information about the last parenthesis
		search done.

Swapping To and From E via RPG startups: ⊗XRSYS ⊗XRUN ⊗XGORPG ⊗XDRD ⊗XTV

  Modes     Command	    Meaning
  N	    DIRED	Swap to the DIRED directory editor
  N	    DRD		Swap to the DIRED directory editor
  N	    GORPG	Swap to SNAIL (RPG) to reexecute last cmd
  N,A,E     RSYS	Run a given system program, with RPG startup
  N,A,E     RUN		Run a given user program, with RPG startup


A user program can start up E and have it automatically edit a
particular file at a specific place, with the capability of returning to
the original program or to any other particular program.  Furthermore, E
has commands that cause it to swap to certain system programs or to any
named system or user program.

In each of these cases, whether coming from E or going to E, the new
program is started up at the so-called "RPG startup address", namely, at
1 beyond the normal starting address.  This is usually done with the
SWAP UUO by specifying a starting-address increment of 1.

The commands to start up another program from E are listed below.
Each of these first puts down any attach buffer and writes out to the
disk any changes on the page before swapping to another program.

    ⊗XRSYS <program>   This runs the given system program (device SYS:)
		       with an RPG startup.  See also next paragraph.

    ⊗XRUN <program>    This runs the given user program (device DSK:)
		       with an RPG startup.  See also next paragraph.

    ⊗XGORPG            This runs the system program SNAIL (formerly RPG)
		       with an RPG startup.

    ⊗XDRD              Either of these runs the system program DIRED
      or	       with an RPG startup.
    ⊗XDIRED

If the <program> is omitted from the ⊗XRSYS or ⊗XRUN command, and if E was
originally run with an RPG startup, then the program run by the command
will be the program whose name was in ACs 0-3 when E was started up (see
below for the AC contents expected by E on an RPG startup).  Thus a
program that wishes to swap to E and to have E swap back to it can set up
the ACs as described below and swap to E using the RPG startup (starting
address plus 1).


When E is run via an RPG startup, it expects certain data to be in the ACs
(placed there before the SWAP was done).  When E starts up another program
via the ⊗XRSYS or ⊗XRUN command, it leaves this same data in the ACs.
This data is listed in the table below.  (RH means "right half" of the
AC, and LH means "left half".)

  AC	Data in AC upon RPG startup (starting address + 1)

   0	Name of program file
   1 LH	Extension of program file
   2	
   3	PPN of program file
   4	
   5	
   6	Device of program file
   7	
  10	
  11	PPN of edit file
  12	Device of edit file or zero for DSK:
  13 LH	Extension of edit file
     RH Mode bits (see below)
  14	Name of edit file
  15 LH	Attached-line count+400000, or column position within line, or zero
     RH	Line number in edit file
  16	Page number in edit file
  17

Coming from E (⊗XRSYS or ⊗XRUN), ACs 0-6 will contain the name of the
program that E is swapping to, and ACs 11-16 will contain the name of the
edit file that was being edited by E.

In swapping to E, ACs 0-6 contain the name of the program that E should
swap back to upon an ⊗XRSYS or ⊗XRUN command given without a program name,
and ACs 11-16 contain the name of the file E should edit.  If AC 14 (name
of edit file) contains zero, E will read the name and starting page and
line of the edit file from the normal editor TMPCOR file (ED), and the
TMPCOR file will be updated upon exit.  Otherwise, the TMPCOR file is
neither read nor written for an RPG startup.

The mode bits in the right half of AC 13 are:

  Bit	Octal	Meaning

  18	400000	Create this file.
  19	200000	Edit in readonly mode (/R).
  20	100000	Edit in no-directory mode (/N).


Message and paragraph handling commands: ⊗∂<cmd> ⊗0⊗∂ ⊗!<cmd> ⊗0⊗!

  Modes     Command	    Meaning
  N,A,E     ⊗∂	    Operate on message with next cmd
  N,A,E     ⊗!	    Operate on paragraph with next cmd


MESSAGE HANDLING COMMANDS: α∂ and αβ∂

The partial-sign (∂) command is designed for easy handling of
messages in mail files, but it can be used on any file regardless of
whether the file contains mail-like messages.  For instance, this
command is capable of attaching (or deleting) a whole page of text at
once and simultaneously deleting the (not in core) pagemark for that page.

The α∂ and αβ∂ commands are search commands used to find the beginnings of
"messages."  A message is defined as the largest contiguous set of lines
of which only the first starts with a partial-sign (∂) and the last of
which is followed either by another line starting with partial-sign or by
the end of the page.  The current message is defined as the message
containing the current line (the arrow line).  If the arrow is on the row
of stars that marks the end of the page, then the current message is the
one that contains the last real line of the page.

The only difference between α∂ and αβ∂ is that the αβ∂ version considers
the current line to be the beginning of a message, even if the line
doesn't start with a "∂".  Thus the α∂ version works on the whole real
current message, whereas the αβ∂ version works on only that part of the
message from the current line forward.

Messages are never considered to extend across page boundaries.  If
neither the current line nor any of the lines preceding it on the
current page starts with a partial-sign, then the current "message"
starts with the first line of the current page.  If none of the lines
(on the current page) below the current line starts with a
partial-sign, then the last line of the current "message" is the last
line on the page.  Thus, if there are no lines on the current page
that start with ∂, then the current "message" is the whole page.

Like the ⊗F commands, the ⊗∂ commands require a following command before
any action is taken (with one exception, which is noted below).  However,
the ⊗∂ commands do not accept a search string before the second command;
⊗∂ always searches for lines beginning with a partial-sign.  If the
command following is one of the special commands that use the number of
lines searched (for instance, by the ⊗F command) as the argument to the
command, then that command will be carried out for the entire current
message.  If the command is not one of these special ones, then it will be
executed at the beginning of the next message.  The special commands that
use the number of lines searched as the command argument are indicated in
the index on p. 3 by the letter "S" in the modes column.

The ⊗∂ commands may be preceded by a numeric argument which specifies
the number of messages (starting with the current one) which the
command is to affect.  If that number is negative, then the messages
just before the current one are the ones effected, with the absolute
value of the argument specifying how many messages.  Note that ⊗-αβ∂
considers the current line to start a message, and so it will work on
the message text immediately before the current line.


N.B.: A zero argument to the ⊗∂ commands means move to the beginning
of the current message WITHOUT WAITING FOR A SECOND COMMAND.  This is
the only case where a second command is not used by the ⊗∂ command.


!!!!! SPECIAL FEATURE OF THE PARTIAL-SIGN COMMAND !!!!!  N.B.: If the
partial-sign command is used with ⊗A (attach) or αβD (delete) to attach
or delete all of the incore text, then the pagemark for that text will
also be deleted.  In particular, if the current page is not the last
page in the file, then the following pagemark will be deleted, leaving
you at the top of that page; if the current page is the last page in the
file, then the preceding pagemark will be deleted and you will be left
at the bottom of the previous page.  No pagemark deleting will be done
if the file has only one page besides the directory, but in this case,
if the file is a message file (extension .MSG) on [2,2], then a flag is
set which will cause the file to be deleted (since there is no text in
it) when you leave it unless you do something to change the file (add
text or pages) before then.  And note that the page deleting only
happens when the entire incore text is either deleted or attached using
the partial-sign command!  Note that since the partial-sign command will
not cross an incore pagemark, this feature cannot apply when you have
two or more pages in core.


If there are already some lines in the attach buffer at the time you
give an ⊗∂⊗A command, the new messages being attached are added at
the end of the attach buffer.  If you give a ⊗-⊗∂⊗A command when
there are already lines in the attach buffer, the new messages being
attached are inserted at the beginning of the attach buffer, ahead of
the text already there.


Here are some example uses of the partial-sign command.  The ones marked
with an asterisk (*) all involve either αβD or ⊗A and will delete a
pagemark in addition to the action noted if the action results in
deleting or attaching all the incore text, unless the current page is
the only page (besides any directory) in the file.


	α∂αβD	  ;* Deletes the current message.
	α∂⊗A	  ;* Attaches the current message.
	α∂⊗C	  ;Copies the current message into the attach buffer.

	⊗0⊗∂	  ;Moves to beginning of current message.
	⊗∂<cr>	  ;Moves to beginning of next message.
	⊗-α∂<cr>  ;Moves to beginning of previous message.

	⊗∂<bs>	  ;Moves to end of current message.
	⊗∂⊗J	  ;Moves to beginning of next message and jumps screen up.
	⊗∂αβ<cr>  ;Enters LINE INSERT mode between the end of the
		  ;current message and the beginning of the next one.

	⊗3α∂αβD	  ;* Deletes three messages starting with the current one.
	⊗3α∂⊗A	  ;* Attaches three messages starting with the current one.
	⊗3α∂⊗C	  ;Copies three messages starting with the current one.

	⊗-⊗2α∂αβD ;Deletes the two messages preceding the current one.
	⊗-⊗2α∂⊗A  ;Attaches the two messages preceding the current one.
	⊗-⊗2α∂⊗C  ;Copies the two messages preceding the current one.

	αβ∂⊗XTYPE<cr>	;Types out text from current line to end of message
	αβ∂⊗XJUST<cr>	;Justifies text from current line to end of message
	αβ∂⊗D		;Deletes text from current line to end of message

	⊗-αβ∂⊗XTYPE<cr>	;Types out text from beginning of message thru line
			; just before current arrow.


PARAGRAPH HANDLING COMMAND: α! and αβ!

The exclamation-point (!) command operates on PARAGRAPHS in the same way
that the partial-sign (∂) command operates on messages.  Thus α! works on
the whole current message, and αβ! interprets the current line to be the
beginning of a paragraph and therefore effectively works on only the part
of the current paragraph from the current line on.

However, UNLIKE the ⊗∂ command, the ⊗! command never deletes a pagemark.

    NOTE: "PARAGRAPH" here means a contiguous group of non-empty lines
    plus certain surrounding empty lines (if any).  Included in the
    paragraph of the ! command are: one empty line (if any) at the
    beginning of the paragraph and all but one of any empty lines at the
    end of the paragraph.  However, if the last line of a page is blank,
    it is considered part of the paragraph containing the previous line.

The two commands ! and ∂ don't actually do anything until you type another
command.  If that following command accepts a search distance argument,
then the effective argument will be the number of lines in the current
paragraph (! command) or message (∂ command); for example, α!⊗XJUST<cr>
will justify the current "paragraph" and αβ!⊗XJUST<cr> will justify lines
from the current line to the first blank line following.  If the command
that follows ⊗! or ⊗∂ does NOT accept a search distance argument, then
that command is carried out after moving to the beginning of the next
paragraph (!) or message (∂).  The one case in which the ! and ∂ commands
don't take a following command is when a preceding zero argument has been
supplied (that is, ⊗0⊗! or ⊗0⊗∂), in which case the command immediately
moves to the beginning of the current paragraph (!) or message (∂).
Macros: ⊗XDEFINE ⊗Z ⊗Y ⊗≡ ⊗∩ ⊗∪ ⊗⊂ ⊗⊃ ⊗$ ⊗% ⊗~ ⊗_ ⊗XCASE ⊗XRESUME ⊗XABORT ⊗# ⊗XSTOPALL ⊗XSTOPONE ⊗XSTOPZERO ⊗XSTOPHOW ⊗XSILENT ⊗XRAPID
	(See following three pages for more about macros.)

  Modes     Command	    Meaning
	    <ESC>I  Terminate macro expansion
  N,A,E     ⊗Y	    Call current macro
  N,A,E     ⊗Z	    Call a named macro
  N,A,E     ⊗#	    (Actually the "#" char) Pass macro call arg to next cmd
  N,A,E     ⊗≡	    Call the macro named "≡"
  N,A,E     ⊗∩	    Call the macro named "∩"
  N,A,E     ⊗∪	    Call the macro named "∪"
  N,A,E     ⊗⊂	    Call the macro named "⊂"
  N,A,E     ⊗⊃	    Call the macro named "⊃"
  N,A,E     ⊗$	    Call the macro named "$"
  N,A,E     ⊗%	    Call the macro named "%"
  N,A,E     ⊗~	    Call the macro named "~"
  N,A,E     ⊗_	    Call the macro named "_"
  N,A,E     CASE	Select and call a macro from a list of macro names
  N,A	    DEFINE	Define a macro
  R,A,E     RAPID	Enable line editor simulator for use in macros
  N,A,E     RESUME	Resume expansion of a macro that was stopped early
  N,A,E     SILENT	Suppress error messages while inside macros
  N,A,E     STOPALL	Set action on macro error to stop all macros
  N,A,E     STOPHOW	Find out setting of macro error action
  N,A,E     STOPONE	Set action on macro error to stop just one macro
  N,A,E     STOPZERO	Set action on macro error to ignore errors



DEFINING AND CALLING MACROS--MACRO NAMES

Macros are provided in E to save the user the effort of typing the same
things over and over again.  A macro represents any number of characters
that should be "typed" to E as commands and text whenever that macro is
called.  A macro is defined with the command

	⊗XDEFINE <macro name><cr>

where <macro name> can contain letters and digits (it can even start with
a digit or contain only digits), or it can be entirely blank, or it can
consist of exactly one of the nine characters below (which characters
appear on the top of the digit keys on DD and III keyboards at SU-AI):
	≡ ∩ ∪ ⊂ ⊃ $ % ~ _
Only the first six characters of a <macro name> are significant, but
beyond that a <macro name> can NEVER be abbreviated.  After giving the
⊗XDEFINE command, the user types the characters (commands and/or text)
which the macro is to represent.  The definition is ended by typing αβ<lf>
on displays or ↑Z on non-displays.  When you end the definition, the
macro's name and definition will be typed out unless the definition was
made during macro expansion (i.e., by another macro).

A macro can be called by either

	⊗Z<macro name><cr>
or
	⊗Y

where the latter calls the last macro either defined or called, except
that a macro whose name is one of the nine special characters (≡∩∪⊂⊃$%~_)
can NEVER be called with the ⊗Y command.  These nine macros, however, can
ALWAYS be called with the corresponding one of the nine single-character
commands

	⊗≡ ⊗∩ ⊗∪ ⊗⊂ ⊗⊃ ⊗$ ⊗% ⊗~ ⊗_

Each of the macro-calling commands causes the macro definition to be
expanded by treating the commands and text of the definition as if they
were being typed in by the user.  The ⊗Y command allows the user to
repeatedly call the same macro with a single keystroke each time, but
only until the user either calls (with ⊗Z) or defines another macro.
Named macros and the ⊗Z command allow the user to define and use as many
macros as he wants.

While macro expansion is in progress, there are no prompts given (like
"Command?"), "OK" is never typed out, and the display is not updated.
However, the ⊗V command given inside a macro causes the display to be
updated immediately.  Thus you can put ⊗V commands into a macro definition
to let you watch the progress of the macro.  Also, you can have a macro
pause for # seconds by putting ⊗#⊗V into the macro at the desired
place(s).


SELECTIVE MACRO CALLING

The following command can be used to select and call one macro from a
list.  In this case the repeat argument to the command determines which of
several possible macros is to be called.  This command is normally used
inside a macro that might want to call some other macro(s).

	⊗#⊗XCASE <macro name> <macro name> ... <macro name><cr>

This command executes the #th macro in the list of macro names, where the
counting of # starts at zero (0); the selected macro is executed with a
repeat arg of 1.  For instance, ⊗2⊗XCASE A B C D<cr> will execute macro C.
The macro names should be separated with spaces.  No macro name in the
middle can be omitted, and the null (blank) macro name cannot be used
here; however, any non-blank names can be supplied, since E does not check
that all such names represent currently defined macros.  If the repeat arg
given to ⊗XCASE is negative, then the command will be aborted.  Since the
extended command line is buffered in E, and since the buffer has a fixed
size, there is an effective limit to the number of macro names that can be
listed in the command line; the current maximum command line length is
about 119 characters -- characters beyond that are ignored.  An error will
occur if there are not enough macro names in the command for the given
repeat arg.


MACRO EXPANSION ENDING -- ALTMODE INSERTED

When all macro expansion is terminated for any reason, an ALTMODE
character is used as the next input character to force completion of any
partially-typed command.  However, there is one major exception to this
rule.

    If the macro expansion runs to completion and the effect of the last
    characters in the macro is to leave a line of text (from the file) in
    the line editor, then the normally-inserted ALTMODE is omitted and the
    text is left in the line editor.


ITERATIVE AND RECURSIVE MACRO EXPANSION

Iteration:  A positive repeat argument on a macro call will cause the
macro to be expanded a number of times.  For example,

	⊗3⊗Z<macro name><cr>
or
	⊗3⊗Y

will cause the macro to be expanded three times.  Negative arguments to
macro calls are reserved for future use, although they currently result
in making a macro call a no-op.  A zero argument will cause the macro
name and definition to be typed out, as explained below.

Recursion:  A macro can call other macros or even itself.  When a called
macro finishes, control returns to the calling macro, which then continues
its own expansion.  A pushdown stack is used to keep track of the macro
calls (expansions) currently in progress.  This macro stack currently has a
length of about 48, thus allowing nested macro calls up to that depth.  Any
attempt to call a macro beyond that depth will immediately terminate all
macros in progress; however, ⊗XRESUME (see below) can be used to continue
macro expansion by skipping the macro call that caused the overflow.


FINDING OUT MACRO NAMES AND DEFINITIONS--STANDARD REPRESENTATION OF DEFINITIONS

Arguments of zero are used to have macros and their definitions typed
out.  The command

	⊗0⊗XDEFINE<cr>

will type out the names of all defined macros.  A zero argument to a
macro call will simply cause the macro's name and definition to be typed
out; that is, use

	⊗0⊗Z<macro name><cr>
or
	⊗0⊗Y
or
	⊗0⊗≡  ⊗0⊗∩  ⊗0⊗∪  ⊗0⊗⊂  ⊗0⊗⊃  ⊗0⊗$  ⊗0⊗%  ⊗0⊗~  ⊗0⊗_

with the second form also being useful for finding out which macro the
next ⊗Y command would call.

Macro definitions are always typed out using a text representation which
allows for the CONTROL and META bits and non-printing characters (such
as formfeed).  This same representation is used when reading or writing
macro definitions from or to the incore page and command files--see p. 27
for those commands.

Actually, there are two representations available, the standard
representation and the alternate representation.  The standard version
is always used for typing out definitions, but either or both can be
used when reading definitions from the incore page or from a command
file.  These representations involve three special escape characters and
several ignored characters.  The characters ignored are

	TAB,ALT,CR,LF,BS,VT, and FF.

The three escape characters are

	"⊗", "α" and "β".

To represent any of the seven ignored characters or any of the three
escape characters, two characters are used, namely, the character "⊗"
(circle-x) followed by a character specifying which special character
you want.  These representations are listed in the table below.

The character alpha (α) causes the next command to have the CONTROL bit
added.  The character beta (β) causes the next command to have the META
bit added.  Thus "αβV" represents CONTROL-META-V.

     Representations	  Corresponding commands to E
   Standard  Alternate
      ⊗⊗	⊗⊗	  ⊗	circle-x
      ⊗;	⊗;	  Ignore text from here to end of line (to CR, LF or FF).
      ⊗⊂	⊗⊂	  Ignore text from here to first right-horseshoe (⊃).
      ⊗=	⊗T	  TAB	horizontal tab
      ⊗≠	⊗A	  ALT	altmode
      ⊗↔	⊗C	  CR	carriage return
      ⊗↓	⊗L	  LF	linefeed
      ⊗↑	⊗B	  BS	backspace
      ⊗←	⊗V	  VT	vertical tab
      ⊗→	⊗F	  FF	formfeed
      ⊗α	⊗X	  α	alpha
      ⊗β	⊗Y	  β	beta
      α		⊗1	  Add CONTROL bit to next command
      β		⊗2	  Add META bit to next command

For example, CONTROL-META-LINEFEED is represented by "αβ⊗↓" or "αβ⊗L" or
"αβ⊗l".  The case of a letter following "⊗" is irrelevant, but
otherwise, if a "⊗" is followed by a character other than those listed
above, an error will result and the command will not be completed.

The escape sequences ⊗; and ⊗⊂ are useful for putting comments into E
command files (e.g., EINIT.CMD) without having the comments taken as part
of the commands to be executed.  The form ⊗; allows you to put a comment
at the end of a line, and the form ⊗⊂ allows you to have partial-line or
multi-line comments.  The ⊗XCOMMENT command can also be used for comments,
but it is actually stored (e.g., in macro definitions) and executed, so it
can only occur where a normal command can occur; furthermore its use
should be avoided inside a macro definition, since it needlessly increases
the size of the macro and slows it down a little.  Note that since TABs
are ignored, you can use them to set off comments or actual commands from
other text in a command file.


Note:  These representations are NOT usable in the ⊗XDEFINE command when
defining a macro from the terminal.  Definitions typed in from the
terminal are entered verbatim--no character conversion.


UNDEFINING MACROS

A macro can be undefined by giving the ⊗XDEFINE command with a negative
argument.  Thus the command

	⊗-⊗XDEFINE <macro name><cr>

makes E completely forget about the named macro.


ERRORS DURING MACRO EXPANSION

The user can select the action to be taken when an error ("SORRY --
...")  occurs inside a macro.  The default action is to stop all macro
expansion, but the user can give any of three extended commands to
select the current error action from three possibilities.

    ⊗XSTOPALL	On error, stop all macro expansion.  This is the default.

    ⊗XSTOPONE	On error, stop the current macro and return control to any
		higher level calling macro as if the current macro had
		finished.

    ⊗XSTOPZERO	On error, ignore the error and let macro expansion continue.

There is one additional extended command to find out what the currently
selected error action is.

    ⊗XSTOPHOW	Report which of the above three actions is currently selected.

Also, any argument given with any of the three previous commands will
suppress selecting an action, but will report the current error action.

When E needs an answer to a Yes or No question while processing some
command, it will get the answer FROM THE USER'S TERMINAL, NEVER FROM A
MACRO DEFINITION.  Unless the answer is Yes, macro expansion is treated
as if a command error had occurred, and the current error action is
taken.

Certain errors that E detects always cause stopping of all macros
in progress, regardless of the current STOPxxx setting.  These errors
are never expected to occur deliberately inside macros, and so they
stop all macro execution as an aid to macro debugging.  The current
such permanent-STOPALL errors for macro execution are:

	Unrecognized command character
	Ambiguous (extended) command
	Unknown (extended) command
	Syntax error in extended command line
	Can't exit while expanding a macro
	Command illegal from line editor here
	Macro pushdown list overflow
	(Syntax error in LISPSYNTAX command)
	Cannot execute a readonly variable
	Macro text for line editor is too long
	Invalid macro name

Note that for the last of these errors above, E's line editor buffer is
considerably bigger than the real line editor's buffer, so it is still
possible to lose some text (without stopping any macro) if a macro's line
editor text is slightly too long for the line editor.


The ⊗XSILENT command suppresses error messages that are generated inside
macros except when such an error would stop all macros.  Thus SILENT mode
can be used to speed up execution (by suppressing the error typeout) in
macros that deliberately cause errors to happen in order to abort one
level of macro execution (in ⊗XSTOPONE mode).  The command ⊗-⊗XSILENT
disables this mode.  The commands ⊗0⊗XSILENT, ⊗0⊗XVERBOSE, and ⊗0⊗XTERSE
all type out the status of SILENT mode (when enabled) in addition to the
status of the TERSE/NORMAL/VERBOSE mode.


ABORTING AND RESUMING MACRO EXPANSION

Four ESCAPE commands are available for interrupting macro expansion.
These are ESC I, ESC 1 I, BRK I, and BRK 1 I.  Two of these, ESC 1 I and
BRK 1 I, affect only macro expansion.  ESC I and BRK I interrupt macro
expansion as well as other E processes, such as multipage searches.
Thus ESC 1 I or BRK 1 I can used when you want to stop a macro but don't
want to interrupt a search in progress.

Typing BRK I or BRK 1 I will terminate the current macro and return
control to any higher level calling macro.

Typing ESC I or ESC 1 I will terminate all macro expansion.  When this
mechanism is used to stop macro expansion, the user can have the
expansion resumed where it left off by giving the command ⊗XRESUME.

The ⊗XABORT command can be used to explicitly abort any number of levels
of macro expansion by popping a number of calls off the macro stack.
This command can be included in a macro definition to automatically end
one or more macro calls, or it can be given from the terminal to cause
the next ⊗XRESUME command to resume macro expansion one or more levels
up from the current macro stack location.  When given WITHOUT an
argument, ⊗XABORT stops all macro expansion--this form is meaningless
except inside a macro.  The ⊗#⊗XABORT command WITH an argument pops the
specified number (#) of macro calls off the macro stack (whether the
macro stack is actively being used or just being maintained for a later
⊗XRESUME).

Whenever all macros have been aborted before completion, the command

	⊗XRESUME<cr>

will resume macro expansion where it left off.  Also, the command

	⊗#⊗XRESUME<cr>

can be given with a decimal argument (#) to find out what macros are in
progress and what text and repeat arguments remain to be processed.  An
argument of ⊗# finds the element which is # calls from the top of the
macro stack and types out the remaining repeat count, the macro call
level, the name, and the remaining text of that macro call.  Thus ⊗0 types
the top of the stack, ⊗1 types the next element on the stack, etc.


PASSING REPEAT ARGUMENTS TO COMMANDS INSIDE MACROS: THE ⊗# COMMAND

The number-sign command, ⊗#, allows one or more commands inside a macro
to access and use the repeat argument given to a macro call.  (In this
paragraph and the table below, "#" represents the number-sign character
itself, NOT an arbitrary number.)  Inside a macro, each occurrence of
the ⊗# command passes the macro call's argument to the next command and
inhibits the repeated expansion of the macro (clearing the effective
repeat count of the macro call).  The actual argument passed to the
command following the ⊗# depends on the arguments given to (1) the macro
call and (2) the ⊗# command itself.  In the simplest case, if one of
these two arguments is omitted, the other is used.  If the argument to
⊗# is relative (preceded with ⊗+ or ⊗-), then the two (signed) arguments
are added together.  The following table shows the resulting argument as
a function of the two "input" arguments, with examples given in
parentheses.  Note that the macro call argument (if any) is always
positive; however, the ⊗# command can be followed by ⊗- to invert the
sign of the resulting argument.  Outside of macro expansion, the ⊗#
command is treated as if you had NOT typed it!

    Arg to        Arg to	 Resulting arg passed
  macro call	⊗# command	to command following ⊗#
 ------------  -------------    -------------------------
     none	 anything	Arg to ⊗# command
    (none)	  (⊗-⊗2)	(⊗-⊗2)

   relative	   none		Arg to macro call
  or absolute   or absolute
    (⊗+⊗5)	  (none)	(⊗+⊗5)
     (⊗5)	   (⊗2)		(⊗5)

   relative	 relative	Relative sum of the two arguments
    (⊗+⊗5)	  (⊗-⊗2)	(⊗+⊗3)

   absolute	 relative	Absolute sum of the two arguments,
				except negative sum is relative
     (⊗5)	  (⊗+⊗2)	(⊗7)
     (⊗5)	  (⊗-⊗7)	(⊗-⊗2)


REQUESTING/SUPPRESSING INFORMATIONAL MESSAGES: ⊗XVERBOSE AND ⊗XTERSE

Certain informational messages will be either typed out or suppressed
depending on the reporting state that E is in: Terse, Normal, or
Verbose.  The reporting state can be set with the ⊗XVERBOSE and ⊗XTERSE
commands, which are described elsewhere.  The Verbose state is useful
during debugging of macros that call other macros.

The following messages are typed out only in Verbose mode.

	Calling ...		;A macro is being called.
	Ending ...		;A macro call has just finished.

The following messages are suppressed only in Terse mode.

	Aborting macro ...	;An error has caused aborting of one
				; macro call while in ⊗XSTOPONE mode.
	Abort of # macros requested from ...
				;A ⊗#⊗XABORT command has been given.


FORMAT OF NAME TYPEOUT FOR MACRO CALL

When a macro call is mentioned in an error or informational message, the
form typed out is usually

	[nX](m)macname

where n is the remaining repeat count for this macro call, m is the
level of this macro call, and macname is the name of the macro.  The
form [nX] will be omitted if n is 1.  A level (m) of 1 represents the
bottom of the macro stack, that is, the level called from the terminal.
Note that macname might be blank, since the blank macro name is
perfectly legal.


LINE EDITING IN MACROS

Line editor commands may be used inside macros, and they will have their
normal effects except that the αD command, when intended to delete the
CRLF at the end of a line (thus joining two lines), MUST be preceded in
the macro definition either with α<tab> or with αK<cr> so that E will be
sure that the αD will be given at the end of the line.  The effect of a
bad use of αD is that characters after the αD in the macro definition
up through the first activation character following are not "typed"
until the macro expansion ends, which can be particularly noticeable if
you use a repeat argument on the macro call.

The above rule about αD also applies to αI, which also should be preceded
by α<tab> when intended to be given at the end of the line editor in a
macro.


LINE EDITOR SIMULATOR FOR MACROS: ⊗XRAPID

In order to reduce execution time for macros that use the line editor, E
uses a line editor simulator whenever possible during macro expansion.
This means that E itself handles certain line editor functions (see
limitations below) to avoid the time-consuming process of shipping text
and commands to and from the line editor.  This should not effect the
results of any macro, but it can speed up certain types of macros by a
factor of 10.

Macros that do not use the line editor are not affected by the existence
of the simulator.

The line editor simulator is fairly primitive in that it can only do a
limited number of line editor operations, but when the simulator cannot
handle a line editor command, the real line editor is used instead.  Thus
macros will work the same with or without the simulator, but execution
time will be reduced if the simulator can handle all the line editor
operations in a given sequence.  Since the simulator avoids doing any UUOs
that invoke the real line editor, line editor simulation is up to 10 times
as fast as real line editor use.

The line editor simulator in E handles almost all commands that do not
change the number of characters in the line.  This includes all cursor
movement commands plus most attempts to overtype characters in the line.
E does NOT handle the following cases: (1) typing over a tab or typing a
tab (because of the variable width of tabs) and (2) insertions and
deletions.  Anytime a macro attempts a line editor function that the
simulator cannot handle, E gives the text and commands to the line editor
to let it carry out the editing on that line (thus ensuring that the
commands get the right result).

Between the time that any new feature gets added to the real line editor
and the time the same feature gets programmed into E's simulator, it is
possible that the simulator will give incorrect results.  Therefore the
simulator can be disabled and re-enabled with the commands show below.
(Of course, it is fairly rare that new features are added to the line
editor.)

	⊗-⊗XRAPID	Disable the line editor simulator which is
			normally used during macro expansion.

	⊗XRAPID		Enable the line editor simulator.

	⊗0⊗XRAPID	Report whether the line editor simulator
			is enabled or disabled.

As the command name suggests, macros involving line editor commands will
usually execute more RAPIDly when the simulator is enabled.

(Currently the default is ⊗-⊗XRAPID; that is, the simulator is disabled.
However this will change very soon.)


EXITING NOT ALLOWED DURING MACRO EXPANSION

The command to exit from E (namely, ⊗E) is not legal coming from a macro
expansion.  This is disallowed to prevent accidental exiting while using
attach mode inside macros, since the command to put down the attach
buffer is the same as that to exit, ⊗E.


*** MORE COMMANDS RELEVANT TO MACROS ARE EXPLAINED ON THE NEXT 3 PAGES. ***

Numeric Macros and Readonly Variables: ⊗XSET ⊗XARGUMENT ⊗XMULTIPLY ⊗XDIVIDE ⊗XREMAINDER ⊗XADD ⊗XSUBTRACT ⊗XMINIMUM ⊗XMAXIMUM ⊗XIFLT ⊗XIFLE ⊗XIFGE ⊗XIFGT ⊗XIFEQ ⊗XIFNE ⊗XCHARACTER
	(See previous page and following two pages for more on macros.)

  Modes     Command	    Meaning
  N,A,E     ADD		Add given repeat arg to macro's value
  N,A,E     ARGUMENT	Set up repeat argument from value of numeric macro
  N,A,E     CHARACTER	Generate the next command character from numeric value
  N,A,E     DIVIDE	Divide macro's numeric value by given repeat arg
  N,A,E     IFEQ	Error unless repeat arg = macro value
  N,A,E     IFGE	Error unless repeat arg ≥ macro value
  N,A,E     IFGT	Error unless repeat arg > macro value
  N,A,E     IFLE	Error unless repeat arg ≤ macro value
  N,A,E     IFLT	Error unless repeat arg < macro value
  N,A,E     IFNE	Error unless repeat arg ≠ macro value
  N,A,E     MAXIMUM	Set macro's value to MAX(<old value>,<repeat arg>)
  N,A,E     MINIMUM	Set macro's value to MIN(<old value>,<repeat arg>)
  N,A,E     MULTIPLY	Multiply macro's numeric value by given repeat arg
  N,A,E     REMAINDER	Set macro to remainder of <old value> / <repeat arg>
  N,A,E,S   SET		Set the value of a numeric macro
  N,A,E     SUBTRACT	Subtract given repeat arg from macro's value



INTEGER-VALUED NUMERIC MACROS

There are numeric macros, whose integer values are represented by strings
of digits (optionally preceded by + or - and optionally followed by
non-digits).  There are several commands to create, operate on, test,
and apply numeric macros.  Numeric macros can be "executed" just like any
other macros; the result is the typing of the simple string of digits into
the text.  The CONTROL and META bits are ignored when evaluating a numeric
macro and are left OFF when E generates a numeric macro.

When a macro is being evaluated for its numeric value, an error will
result if the macro definition doesn't start with a string of digits
(optionally preceded by + or -); the evaluation is terminated by any
non-digit (not including a leading + or -).  The maximum absolute value
that can be generated without error during evaluation of a numeric macro
is 2↑35 - 1.  Larger numeric values will give undefined results.  The
largest possible absolute value of the repeat argument for any command is
2↑17 - 8; larger repeat arguments will be limited to this maximum absolute
value (with proper sign preserved).

The only difference between numeric and non-numeric macros is that
evaluating (as opposed to executing) a non-numeric macro will result in an
error.

   ⊗XARGUMENT <macro>   Sets up a repeat argument for the following
			command from the named numeric macro.  Any arg
			given to the ⊗XARGUMENT command itself is added to
			the value from the macro before setting the
			resultant argument.  If the macro's definition
			starts with "+", the resultant argument will be
			relative, as if ⊗+ were typed.  The largest
			possible absolute value of the repeat argument is
			2↑17 - 8; larger repeat arguments will be limited
			to this maximum absolute value (with proper sign
			preserved).

   ⊗XSET <macro>        Sets the named macro to the string of decimal
			digits (possibly preceded by + or -) that
			represents the command's numeric repeat argument.
			This command accepts a search distance as the
			repeat argument.

   ⊗XSET <macro1> ← <macro2>
			Copies the definition of <macro2> into <macro1>.
			The FIRST macro name CANNOT be blank when this
			form of ⊗XSET is used, but the SECOND name CAN be
			blank (meaning the blank-named macro).  The second
			name can be that of a readonly variable (ending
			with "."), in which case the first macro gets
			defined as the string of digits that represents
			the readonly variable's current decimal value.
			This command is needed to copy large-valued
			numeric macros, since
			    ⊗XARGUMENT <macro2><cr>⊗XSET <macro1><cr>
			will truncate <macro2>'s absolute numeric value
			to 2↑17 - 8, which is the maximum legal repeat
			argument.  The ⊗XSET command will be aborted if E
			can't figure out what you want.  Equals-sign (=)
			can be used in place of the left-arrow (←).

Of course, all the commands that work on macros work just as well on
numeric macros, but the following commands deserve particular mention here
since they are important in conjunction with the commands for numeric
macros.

   ⊗0⊗Z <macro>		Types macro's definition.
   ⊗Z <macro>		Executes the macro.
   ⊗-⊗XDEFINE <macro>	Undefines the macro.

The following commands operate on the numeric value of a given macro.  If
the macro's old value started with "+", then the new value will start with
"+" unless the new value is negative.  CONTROL and META bits are ignored
in the macro's old value and are left OFF in the new value.  As usual, if
no repeat argument is given, ⊗1 is assumed; thus ⊗XADD TOTAL<cr> adds 1 to
TOTAL.  In the ⊗XDIVIDE and ⊗XREMAINDER commands, the remainder has the
same sign as the dividend and the quotient is not rounded.

   ⊗XMULTIPLY <macro>	Multiply macro's numeric value by given repeat arg.
   ⊗XDIVIDE <macro>	Divide macro's numeric value by given repeat arg.
   ⊗XREMAINDER <macro>	Make macro's new value be the remainder from the old
			value divided by the given repeat arg.
   ⊗XADD <macro>	Add given repeat arg to the macro's value.
   ⊗XSUBTRACT <macro>	Subtract given repeat arg from the macro's value.
   ⊗XMAXIMUM <macro>	Set macro's value to MAX(<old value>,<repeat arg>).
   ⊗XMINIMUM <macro>	Set macro's value to MIN(<old value>,<repeat arg>).

Each of the following "IF" commands compares the command's repeat argument
against the value of a given numeric macro.  If the test proves true,
nothing happens, but if the test fails, then an error will result (which
can be used to terminate macro expansion).  As usual, if the repeat
argument is omitted, ⊗1 is assumed.

   ⊗XIFLT <macro>	Error unless repeat arg < macro value
   ⊗XIFLE <macro>	Error unless repeat arg ≤ macro value
   ⊗XIFGE <macro>	Error unless repeat arg ≥ macro value
   ⊗XIFGT <macro>	Error unless repeat arg > macro value
   ⊗XIFEQ <macro>	Error unless repeat arg = macro value
   ⊗XIFNE <macro>	Error unless repeat arg ≠ macro value


READONLY INTERNAL E VARIABLES

There are certain always-defined readonly variables whose values can be
accessed with most of the numeric macro handling commands.  These
variables include the current page number, the current line number, the
current column position, etc.  The complete list of variables is given
below (more can be added if necessary).

Here are the commands that accept either a readonly variable name or a
macro name.  See the individual command descriptions for what these
commands do with the value of the variable or macro.  Commands in the
second and third columns below (like ⊗XMULTIPLY) normally set (in addition
to using) a numeric macro value; when given a readonly variable name those
command merely type out the resultant value.

   ⊗XARGUMENT	   ⊗XMULTIPLY	   ⊗XADD	   ⊗XIFLT
   ⊗0⊗Z		   ⊗XDIVIDE	   ⊗XSUBTRACT	   ⊗XIFLE
		   ⊗XREMAINDER	   ⊗XMAXIMUM	   ⊗XIFGE
				   ⊗XMINIMUM	   ⊗XIFGT
						   ⊗XIFEQ
						   ⊗XIFNE

Here are the current readonly variables.  The names of readonly variables
CANNOT be abbreviated; and they all end with dot (.) to distinguish them
from macro names (which can occur wherever readonly variable names can).
For the purpose of these variables, the current character is the first
character on a line unless the command (from the above list) was given
from the line editor, in which case the current character is the one the
cursor was under when the command was given.  The variables below that are
marked with an asterisk (*) do not take into account any changes so far in
the current line if the variable is being evaluated from the line editor;
thus these variables return the value that would result if <altmode> were
typed immediately (this effect may or may not be changed).  The remaining
variables return the current accurate value even when given from the line
editor.

  READONLY
  VARIABLE   VALUE
  --------   ------
   LINE.     Number of the current line within the current page.
 * LINES.    Number of lines on the current page.
   PAGE.     Number of the current page.
   PAGES.    Number of pages in the file.
   COL.      Number of the current column, where 0 is the left margin.
   COLS.     Number of columns taken up by the current line.
   COLINT.   The current "column of interest" for the α; and α: commands.
   CHAR.     Number of the current character within the current line, where
	     0 is the first character in a line.  There is a difference
	     between CHAR. and COL. if and only if there are tabs ahead of
	     the cursor in the current line.
   CHARS.    Number of characters in the current line, not counting the
	     CRLF at the end of the line.  This value will be 0 if the
	     current line is empty and -2 if the current "line" is the end
	     of a page.
   CORLIN.   Number of the current line among all incore text.
 * CORLNS.   Number of lines of incore text (including incore pagemarks).
 * CORCHS.   Number of characters of space taken up by the incore text, not
	     counting nulls at the end of the final incore page.
 * ROOM.     Number of additional characters there is room for among the
	     incore text before expanding ("X") the page(s) is needed.  The
	     sum of CORCHS. and ROOM. is the amount of disk space, in
	     characters, currently allocated to the incore text.
   CORBEG.   Number of the first incore page.
   COREND.   Number of the last incore page.
   ASCII.    Ascii character code for the current character.  This will be
	     13 (decimal code for <cr>) if the current line is empty or if
	     the cursor is positioned at the end of the line.  This value
	     will be 12 (decimal code for <ff>) if the current "line" is
	     the end of a page.
   SIXBIT.   Sixbit character code for the current character.  This is made
	     from the ascii value by subtracting 64 (decimal) from ascii
	     character codes from 96 to 127 (decimal, inclusive) or 32
	     (decimal) from ascii character codes from 0 to 95 (decimal,
	     inclusive).  Thus, the characters with ascii codes 0 through
	     31 (decimal) have negative sixbit codes.
   TOPSIZ.   Number of screen lines not used at top of screen (normally 2,
	     to allow for wholine).
   BOTSIZ.   Number of screen lines used at bottom of screen for typeout
	     and echoing (in the page printer).
   WINSIZ.   Number of screen lines used to display text (does not include
	     lines used for the header and trailer).
   ATTSIZ.   Number of lines currently attached.
   ATTMAX.   Maximum number of attached lines that will be displayed.
   SSLINE.   Current search limiting line number, for all incore text.
   SSPAGE.   Current search limiting page number.

The following readonly variables can be used to examine the justification
margins.  Those with the initial letter T are the margins for the ⊗X TJxxx
commands; those without the T are for the normal ⊗X Jxxx commands.

  CMAR.  TCMAR.  Crown line indent (first line of paragraph).
  LMAR.  TLMAR.  Left margin (amount of indentation for body of paragraph).
  RMAR.  TRMAR.  Right margin; last column that will be used for text.
  BNUM.  TBNUM.  Blank line count; number of blank lines between paragraphs.
  CMARO. TCMARO. Old crown indent; a line with CMARO indentation is taken as
  LMARO. TLMARO.  starting a new paragraph, unless CMARO = LMARO.

There are three readonly variables for finding out how many occurrences of
the current search string were
	(1) searched for:    NFIND.
	(2) found:	     NFOUND.
	(3) substituted for: NSUBST.
in the last search (or substitution) command.  If that search included at
least one successful substitution, then NFOUND. will be zero and NSUBST.
will be positive.  If the last search did not do (but maybe tried and
failed) any substitutions, then NSUBST. will be zero and NFOUND. will be
the number of occurrences found (possibly zero).  NFIND. contains the
requested number of search or substitution repeats.  The only slightly
obscure case is a command like ⊗4⊗F...⊗\...αβ9<cr>, which asks to do 9
substitutions starting with the 4th occurrence; if less than 4 occurrences
are found, then NFIND. will be 4, NFOUND. will be less than 4, and NSUBST.
will be zero, but if 4 or more occurrences are found, then NFIND. will be
9 (NOT 4), NFOUND. will be zero (meaning we did some substitutions), and
NSUBST. will be the number of substitutions done.



GENERATING CHARACTERS FROM NUMERIC VALUES

The command ⊗#⊗XCHARACTER <numeric code for character> <cr> has the same
effect as typing ⊗#<character>.  Note that any repeat arg for the extended
command is passed to the indicated character, which should be between '001
and '777 inclusive (and the low-order 7 bits must not be zero); thus the
CONTROL ('200) and META ('400) bits can be included in the character.  The
⊗XCHARACTER command is primarily for macros that want to generate text
and/or commands from numeric calculations, but it can also be used to type
any command character(s) that your keyboard cannot otherwise input (e.g.,
if some key is broken).  (Note that ⊗XCHARACTER isn't legal in the middle
of another command, so you can't always avoid typing a certain character.)

The character's numeric code can be entered as a constant (decimal, unless
preceded by right single quote (') which makes it octal); or it can be
entered as the name of a numeric macro or readonly variable, in which case
the value of the named entity will be used.  Thus, the command
αβ2⊗XCHARACTER ASCII.<cr> will cause the current character to be typed
twice.


SPECIFYING FOLLOWING NUMERIC ARGUMENTS TO EXTENDED COMMANDS WITH
    NUMERIC MACROS, READONLY VARIABLES, AND OCTAL CONSTANTS

Certain extended commands that normally take one or more decimal numbers
following the command name will accept the name of a numeric macro or
readonly variable in place of the decimal constant.  For instance,
⊗XBREAK RMAR.<cr> will break the current line at the column that is the
right margin for the normal justification commands.

The same extended commands (see list below) will also accept an octal
constant instead of decimal.  Octal is indicated by preceding the number
with a right single quote ('); for instance, ⊗XBREAK '177<cr>.

The commands that currently accept these alternative forms for a number
following the command name are:
	⊗XBREAK
	⊗XCHARACTER
Eventually almost all extended commands will accept these alternative forms.


*** ADDITIONAL COMMANDS RELEVANT TO MACROS ARE EXPLAINED ON THE NEXT 2 PAGES. ***

Macros and Command Files: ⊗XEXECUTE ⊗PUTDEFS ⊗XCOMMENT ⊗XATTACH ⊗XREDEFINE
	(See previous two pages and following page for more on macros.)

  Modes     Command	    Meaning
  N,A,E     ABORT	Abort one or more macros levels in progress
  N	    ATTACH	Place an editable macro definition in the attach buffer
  N,A,E     COMMENT	No-op, useful for putting comments in command files
  N,A,E     EXECUTE	Read and execute commands from a file
  N,A,E     PUTDEFS	Write out all current macro definitions in a cmd file
  N,A	    REDEFINE	Define a macro from incore page or attach buffer



EXECUTING COMMANDS FROM A FILE

To allow macro definitions and other often used commands to be carried
out automatically, the ⊗XEXECUTE command causes a set of commands to be
read in from a specified command file and then executed.  The form of
this command is

    ⊗XEXECUTE <filename> ( <page range> ) <cr>

where <filename> and the parentheses and <page range> are optional.  This
causes the selected pages in the named file to be read into a macro whose
name is the file's primary name with a leading dot; then this "file macro"
is expanded just like any other macro.  If the <filename> is omitted, the
last execute filename given is used; if no previous execute filename has
been given, then the default filename is used: EINIT.CMD on your LOGIN
disk area.  If a <filename> without an extension is given in the ⊗XEXECUTE
command, the default extension .CMD is used.  With a zero argument, this
command

	⊗0⊗XEXECUTE<cr>

will just type out the current default execute file.  The <page range> can
be either a single decimal page number, or a pair of numbers separated by
a colon, (for example, 3:4).  Note that multiple page ranges (such as COPY
allows) are not permitted.

The ⊗XEXECUTE command ignores E directories and SOS line numbers and
accepts the standard and alternate representations to allow for input of
the CONTROL and META bits and non-printing characters from command files.
These representations, which use "⊗" as an escape character, are explained
on p. 25.


WRITING MACRO DEFINITIONS INTO COMMAND FILES: THE ⊗XPUTDEFS COMMAND

The extended command

	⊗XPUTDEFS <filename><cr>

writes all macro definitions into the file given, or into the default file
if no filename is specified.  If the file already exists, it is extended
with a new page added.  If the file doesn't exist, it is created with an E
directory.  This command has the same default file (initially EINIT.CMD on
your LOGIN disk area) and default file extension (.CMD) as the ⊗XEXECUTE
command.  The definitions are written out using the standard
representation, which is explained on p. 25.


COMMENTS IN COMMAND FILES

The recommended way of including comments in a command file is to use one
of the escape sequences "⊗;" and "⊗⊂" to indicate that the text following
is to be ignored as the file is read.  In this way, the comments can be
included without having to be taken as commands to be executed.  The form
"⊗;" allows you to put a comment at the end of a line, and the form "⊗⊂"
allows you to have partial-line or multi-line comments (see p. 25 for
details).

Note that since TABs are ignored, you can use them to set off comments or
commands from other text in a command file.  However, spaces are not
ignored, so if you use them (outside a comment), they will appear in the
text to be executed.

The ⊗XCOMMENT command can also be used for inclusion of comments in a
command file, but it is actually stored (e.g., in macro definitions) and
executed, so it can only occur where a normal command can occur;
furthermore its use should be avoided inside a macro definition, since it
needlessly increases the size of the macro and slows it down a little.
The ⊗XCOMMENT command does nothing; it ignores the entire command line.
Thus the following command does nothing inside a command file.

	αβXCOMMENT This is a bunch of text that can occur on many lines in
	a command file.  It might, for example, document what nearby text
	does.  This command should be ended with a carriage return, which
	in a command file must occur as the two characters circle-x and
	double arrow!  Any ALPHA character inside a COMMENT command line
	in a command file must be quoted (as "⊗α") or it will generate the
	CONTROL bit on the next character and terminate the COMMENT
	extended command line.  Similarly any other character combination
	that generates an activation character (like linefeed or altmode)
	will terminate the COMMENT command. ⊗↔


ATTACHING/EDITING/REDEFINING MACROS

The ⊗XATTACH and ⊗XREDEFINE commands can be used to edit and redefine
macros.  The ⊗XATTACH command loads the attach buffer with the definition
of a macro in standard representation (see p. 25), thus allowing you to
put the text into the current file and edit it.  The ⊗XREDEFINE command
(re)defines a macro from incore text, using the standard and alternate
representations.  The forms of these commands are

	⊗XATTACH <macro name><cr>

	⊗#⊗XREDEFINE <macro name><cr>

where the blank macro name will be used if <macro name> is omitted and the
argument (#) to ⊗XREDEFINE determines how many lines (starting at the
current line or at the first line of the attach buffer) are used as the
source of the macro definition.  As usual, a negative argument represents
lines before the current line.  If no argument is given to ⊗XREDEFINE, the
whole page or whole attach buffer is used as the macro definition source.
The ⊗XATTACH command cannot be given when there is already some text
attached.


*** ADDITIONAL COMMANDS RELEVANT TO MACROS ARE EXPLAINED ON THE NEXT PAGE. ***

Debugging macros: ⊗XSAY ⊗XAUTOSTEP ⊗XSTEP ⊗&
	(See previous three pages for more on macros.)

  Modes     Command	    Meaning
  N,A,E     ⊗&	    Step macro execution # steps
  N,A,E     AUTOSTEP	Set or read autostepping time for macros
  N,A,E     SAY		Type out text and/or decimal number
  N,A,E     STEP	Step macro execution # steps



TYPING OUT INFORMATION (E.G., FROM WITHIN A MACRO)

The command ⊗XSAY simply types out (1) the text on the command line after
"SAY " and then (2) the decimal repeat arg, if any.  The typeout is ended
with a <crlf> if and only if αβX is used in the command.  This command can
be useful inside macros to report the status of the macro execution, but
it works outside of macros as well.


UPDATING THE DISPLAY DURING MACRO EXECUTION

The ⊗#⊗V command causes E to update the display immediately and then pause
# seconds.  If the ⊗# is omitted, then E will merely update the display
without pausing.  These commands can be useful for watching the progress
of a macro.


DEBUGGING MACROS BY STEPPING

Some facilities are provided to allow the user to debug even complicated E
macros.  With these facilities, it is possible to step through macro
expansion (possibly pausing a little at each step) while having the
display updated to see the result of each step or of selected steps in the
macro expansion.  While E is stepping a macro, it will type out the
characters of each step just before that step is carried out.  Whenever E
is pausing at a certain macro step, ESC I will, as usual, immediately
abort all macros in progress.  When a macro step pause occurs from the
line editor, the display of the line editor text will be done by E and a
cursor will be displayed at the proper character within the line.  This
pausing in the "line editor" can be identified on DDs and IIIs by the
slightly wider cursor and on DMs by the "line editor" text NOT being
displayed in BOLD; this is to avoid fooling you into thinking that the
macro has ENDED in the line editor.

A macro step generally involves one complete E command -- for instance not
just ⊗X but a whole extended command line when ⊗X is encountered.
However, any sequence of all line editor commands given from WITHIN the
line editor, none of which would activate the line editor, is treated as a
single step along with the first (complete) command that does activate the
line editor.  Such a sequence does not include the command that made E
enter the line editor; that command is taken as a separate step.
Exception: If the command that enters the line editor is α<tab> or αI,
then no step occurs at that point because it would cause loss of line
editor status (being at end of line or in line editor insert mode).

The ⊗#⊗XAUTOSTEP command enables a mode in which EVERY macro called is
executed by pausing # seconds after each step.  See the paragraph above
for what constitutes a single step.  The command ⊗-⊗XAUTOSTEP disables
this mode of automatic stepping of macros, and ⊗0⊗XAUTOSTEP reports the
status of this mode.  The readonly variable STEP. contains the number of
seconds per pause, or a zero or negative number if autostepping is
disabled.

For manually stepping macros, there are two commands available:
	⊗#⊗XSTEP <optional macro name> <cr>
	⊗#⊗&
The extended command version optionally takes a macro name following the
command name; if a macro name is given (the blank name is not permitted),
then this command will call that macro and execute # steps before
stopping (a repeat arg of 1 will be used for this macro call).  If no
macro name is given with ⊗XSTEP, or if the command ⊗& is used, then macro
execution is RESUMED (where it previous left off) for # steps (where # is
the argument to the command); thus when macro execution has been
interrupted, you can single step the remainder of the macro(s) with the
⊗& command.  Another difference between ⊗& and ⊗XSTEP is that the latter
will cause an explicit message to be typed out when the given number of
steps have been executed -- "Stepping done, in <macro name>"; this
message is always suppressed for the ⊗& command and by Terse mode with
the ⊗XSTEP command.  Note that if you give one of the stepping commands
while in AUTOSTEP mode, E will still pause after each step, but it will
quit stepping when the stepping count has been exhausted.
BOOK MODE (/B) and the BOOK command

Book mode (/B) in E provides some special features for editing files,
especially files which are really books in disguise.  The main feature
of book mode is that you cannot alter a file open in this mode.  In
addition, the BOOK command allows you to read a file in book mode over a
long period of time without having to explicitly remember your place in
the file.  Your place will be saved in a .BKP file.

You get into book mode by following the filename with /B when you are
starting to edit, or by using the BOOK command to edit the file.

1. In /B mode, E will never permit you to alter the file you are
editing; you cannot change to READONLY mode or READWRITE mode from /B
mode.  In /B mode, if you change part of a page and try to write out
the new version, E will simply remind you that you cannot alter the
file.

2. To help you keep your place in a book-file you are reading, E
keeps a special psuedo-SNAIL file on your area.  This file will have
the name <filnam>.BKP, where <filnam> is the primary name of the
book-file.  Note that the .BKP file is NOT a SNAIL file (although it
is in SNAIL file format), and thus will never be deleted by LOGOUT.
This .BKP file will contain the page number and line number at which
you were editing the book-file the last time you exited from E.  E
will neither look for nor write a .BKP file unless you have started E
with the monitor command BOOK, which automatically starts E in /B
mode looking for a .BKP file.  Furthermore, when you start E with the
BOOK command, if you use either of the /L or /P switches, E will
not read or write any .BKP file.  And if you start E with just the
BOOK command without any argument, then unless there already is
a .BKP file on your area, no new .BKP file will be written.

3. The BOOK command with an argument (and without either of the /L
and /P switches) will look for a .BKP file with the given name and
PPN.  If that .BKP file is not found, E will look for the .BKP file
on your current ALIAS area and then on your logged-in area.  If a .BKP
file is found, it is used and updated when you exit.  Otherwise, a
new .BKP file will be written onto your (ALIAS) area when you exit.

4. Whenever you use E in /B mode, it will reference TMPCOR files with
the name BK instead of ED.  Thus you can switch back and forth
between editing some program and reading a book by alternately giving
the no-argument monitor commands ETV and BOOK (provided you have once
given the filenames).  In /B mode, E will display "/B" following the
filename at the top of the screen.

5. When you have finished reading a book-file, E will delete the
<filnam>.BKP file automatically.  E will think you have finished
reading the book if and only if you are on the last page of the file
when you exit.

- - - - -

The complete book WUTHERING HEIGHTS by Emily Bronte is available for
general reading in the file WUTHER[LIB,DOC].  To begin reading it,
simply give the monitor command:

.BOOK WUTHER[LIB,DOC]

Then when you exit from E, the file WUTHER.BKP will have been written
onto your (ALIAS) disk area with the numbers of the page and line
where you were last reading.  To continue reading the file later
during the same login session (and with the same ALIAS as before),
simply say:

.BOOK

which will read in the TMPCOR file BK for your current ALIAS.  When
you exit again, the TMPCOR file and the .BKP file will be updated.

To continue reading after you have logged out and back in, say:

.BOOK WUTHER

which will cause E to find your .BKP file, which itself will contain
the name of the book-file WUTHER[LIB,DOC].

Some other book-files will be found on the [LIB,DOC] disk area, including
GRIMM which is Grimm's Fairy Tales.

- - - - -

To read a file in /B mode without having the <filnam>.BKP file read
or written, use the /B switch explicitly:

.ETV <filename>/B

E files extended by other programs.  ⊗XUPDATE ⊗-⊗XUPDATE

  Modes     Command	    Meaning
  N,A	    UPDATE	Write out the updated incore directory


E can handle easily almost any file that has been extended by another
program even though the directory has not been updated by that program.
The single restriction is that the file must remain in correct E format
with Formfeeds occurring only as the first character in a record.  MAIL
extends E-format files in this way.

When E encounters a file that is longer than the directory indicates, the
file is read from the last indicated page to the end of the file to make
sure that the file is properly formatted.  If the file is formatted ok,
then E generates in core an updated version of the directory, including
directory lines for any new pages added to the file.  The updated
directory is normally not written out onto the disk until some command
forces one or more other pages to be written on the disk.  Furthermore,
in /-U mode (see the /-U switch on p. 20), the writing out of the updated
directory is suppressed even when normal text is being written out.

When E opens a file that has been properly extended in the above manner,
it reports the number of pages that have been added to the file, or, if
none, the number of records by which the last page has been extended.
Also, if any pages have been added, the default position within the file
(at which E will place you if you gave no specific page number in a /#P
switch) is the first newly added page.

As long as an updated directory remains not written out onto the disk, a
"U" (for update) is displayed on the top line of the screen.  The first
time any page is changed and written out when not in /-U mode, or if the
⊗XUPDATE command is given, the updated directory will be written out and
the "U" will disappear.

   ⊗XUPDATE     Go into /U mode (if formerly in /-U mode); see the /-U
		switch on p. 20.  Also, if the directory needs updating on
		the disk, then write it out now; and in that case, also
		write out the current page if it has changed since it was
		last written out.

  ⊗-⊗XUPDATE	Go into /-U mode.  This disables normal updating of the
		directory that would occur when (1) a directory line
		changes or (2) the file is extended beyond what the
		directory page formerly indicated.  See the /-U switch
		on p. 20 for details of /-U mode.

  ⊗0⊗XUPDATE	Just report whether or not /-U mode is in effect.
Filenames, numeric extensions, and filehacks

FILENAMES

If the filename you select to edit does not include an extension, then E
will first look for the file with the null extension.  If that file does
not exist, E will edit the file (with the given primary name and PPN)
that has the "best" extension.  The "best" extension is found by
checking extensions against E's ordered list of good extensions (i.e.,
.FAI, .SAI, .PUB, etc).  If no good extension is found, E will edit the
first file it finds in the UFD that has the right primary name and any
extension except those in E's bad extension list (e.g., .DMP, .XGP,
etc).  To edit a file with a "bad" extension, you must type the
extension explicitly unless the file with the "bad" extension is the
only file in that disk area with the given primary name.

If you omit the programmer name from the PPN in a filename, E will use
your current alias programmer name.  If you omit the project name, E
will use your current alias project name.


NUMERIC FILENAME EXTENSIONS

You can ask E to edit the file with a given primary name and the
greatest numeric extension by giving the extension consisting of just a
greater-than sign (">").  For example,

	ET FOO.>

will edit the file (with primary name FOO) whose extension is the
largest (purely) numeric value.  E.g., if only FOO.20 and FOO.100 exist,
then ET FOO.> will edit FOO.100.  If no file is found with a numeric
extension, then ET FOO.> will report File Not Found: FOO.>.


FILEHACKS

The following filehacks, also usable with the COPY program, are
available in E as filenames.  The file represented by each is indicated
below; all these files are on the [2,2] disk area.  A filehack consists
of a backslash followed by a name from the list below; the name may be
abbreviated by as many letter as necessary to identify it uniquely
(current abbreviations are given below).  A filehack takes the place of
the filename and can be followed by the usual switches.  Note that some
of the files below are not usually maintained in E format; beware.

Some of these filehacks imply /R mode.  These are indicated in the list.
To override a default /R mode, you can explicitly specify /-R after the
filehack.

FILEHACK  ABBR  /R?  FILE
\MAIL	  \M	No   The current user's mail file.
\MSG	  \M	No   The current user's mail file.
\PLAN	  \P	Yes  The current user's plan file.
\PLN	  \P	Yes  The current user's plan file.
\NAP	  \NA	Yes  The current user's NS notifications file.
\NS	  \NS	Yes  The current user's NS notifications file.
\BBOARD   \B	No   The system bulletin board file: BBOARD.TXT[2,2].
\GRIPES	  \G	No   The system gripe file: GRIPES.TXT[2,2].
\GOLD	  \GO	No   The file of old system gripes: GRIPES.OLD[2,2].
\NOTICE	  \NO	Yes  The system message file: NOTICE.TXT[2,2].
\NEWS	  \NE   Yes  The current NYT news summary.
\DIGEST   \DI	Yes  The current AP news digest.
\DOWN	  \DO	Yes  The system downtime forecast file.
\DAY	  \DA	Yes  The message-of-the-current-day file.
\FORWARD  \F    Yes  The forwarding file for the MAIL system.

The filehacks \MAIL, \MSG, \PLAN, \PLN, \NAP and \NS can have an
explicit programmer name specified, in which case the mail, plan, or
notification file for the named programmer is read instead of your own.
To specify a programmer name, follow the filehack name immediately with
a colon (:) followed by the desired programmer name.  For instance,
\MAIL:FOO represents FOO's mail file, and \PLAN:BAZ is BAZ's plan file.
The ⊗XPOINTER command will recognize these programmer-name filehacks (as
well as the normal filehacks).  The filehack names themselves can be
abbreviated as usual (e.g., \M:FOO is FOO's mail file).  The
programmer-name filehack facility is designed for non-display users,
since display users could already enter a filename like ∂FOO or
∂BAZ.PLN.


EDITING THE E MANUAL FILE, E.ALS[UP,DOC]

The special filename consisting of just a question mark ("?")
represents the name of the E manual (this file).  Thus the monitor
command

	ETV ?<cr>

will cause E to edit this manual file in readonly mode.  When you are
already in E, the command ⊗? will switch to the E manual file; see p. 15.
Generating a new directory line: ⊗XNDFAIL ⊗XNDSAIL ⊗XNDBBOARD

  Modes     Command	    Meaning
  N	    NDBBOARD	Make a New Directory line for a page in \BBOARD
  N	    NDFAIL	Make a New Directory line (FAIL type) for page
  N	    NDSAIL	Make a New Directory line (SAIL type) for page


Two commands ⊗XNDFAIL and ⊗XNDSAIL generate and insert a new first line of
the page (called the directory line) in appropriate FAIL and SAIL formats
for labels and for specified categories.

These commands apply to the current page.  If more than one page is in
core (through the use of ⊗XAPPEND or β<ff> commands) then the information
will be gathered only from the page containing the arrow line and the new
line will appear at the start of this page.  Other pages in core at the
time will be unaffected.

The ⊗XNDSAIL command may be used as an information source in a variety of
different ways.  It is not intended for use with text material.

  ⊗XNDFAIL      Generate a New Directory line for the current page for a
		FAIL-type (or MACRO-type) source file.  All symbols
		defined on the current page will be listed in the new
		directory line, with the following restrictions:

		(1) The symbol definition must be the first thing on a
		    line (not counting spaces and tabs).  Thus only one
		    definition per line will be noted.

		(2) The symbol itself must not be over 20 characters long,
		    can contain only letters, digits and the characters
		    ".%_$", and must be followed by colon (:), left-arrow
		    (←) or equals-sign (=).  Thus, normal labels and
		    assignments (in either FAIL or MACRO) will be noted.

		This command ignores down-arrows (↓) at the beginning of a
		symbol and can be made to list only symbols defined with
		a certain number of up-arrows (↑), depending on what
		activation character ends the ⊗X command line.

		Activator  Symbols listed

		   <cr>    All symbols detected (as described above).
		  α<cr>	   Symbols defined with at least one up-arrow (↑).
		 αβ<cr>	   Symbols defined with at least two up-arrows (↑↑).

		The ⊗XNDFAIL command does not take a repeat argument
		(unlike ⊗XNDSAIL below).  The command ⊗0⊗XNDFAIL (with a
		zero repeat argument) will issue a warning message (not an
		error) without doing anything else.


  ⊗XNDSAIL      Generate a New Directory line for the current page for a
		SAIL-type source file.

		Given with a <cr> termination, this command lists all
		words that are preceded by certain category words, the
		default words being RECORD!CLASS, RECORD_CLASS and
		PROCEDURE.

		Having found a category word, E lists the first word
		following the category word and then ignores any following
		text until either a comma or a semicolon is encountered.
		When a semicolon is encountered, the search for a new
		category word is resumed.  If, on the other hand, a comma
		is encountered (not however within parentheses) then the
		next word is taken as another example of the category and
		it is listed, preceded by a comma.  Listings following
		different category words are separated by spaces.

		The default categories may be augmented or replaced by any
		desired categories up to the limit of 4 categories, as
		outlined below.

		(1) One additional category may be specified by typing its
		    name after a space following the command name and
		    terminating it by a <cr>.

		(2) Up to 4 new categories may be specified (separated by
		    commas) with the categories after the first one
		    replacing the default categories, one by one.  To
		    retain some default categories the list is terminated
		    by a <cr>.

		(3) If the typed list of categories is terminated by ⊗<cr>
		    then only the typed categories are used, and the
		    default ones are eliminated.

		(4) If the command is terminated by ⊗<cr> without any
		    typed category names then the original default
		    categories are reinstated.

		The command ⊗0⊗XNDSAIL (with a zero repeat argument) will
		accept any typed categories and then will list the
		categories that are in effect without generating a text
		line.


UPDATING EDIT DATE IN \BBOARD FILE: ⊗XNDBBOARD

The command ⊗XNDBBOARD (New Directory-line for \BBOARD) generates a new
directory line for the current page from the old directory line, assuming
it is in the MAIL message header format or the ⊗XNDBBOARD format.  These
two formats are distinguished by whether the first space in the line is
followed by a second space.  If so, then is MAIL format and this command
flushes the original time from the header and inserts the current date and
the current user's programmer name after the original programmer name.  If
the old directory line was already in ⊗XNDBBOARD format, then the update
date is replaced by the current date and the updating programmer name is
replaced with the current user's programmer name.  No guarantees are made
about what this command will do with a page whose first line is in any
other format.  Note that this command does not delete the old header line
(the user should do that himself), but it does replace any initial
partial-sign (∂) in that line with a greater-than sign (>) to make sure
the ⊗∂ command will still work on the whole message.
Altering the use of the display screen: ⊗XTOPSET ⊗XBOTSET ⊗XATTSET ⊗XHEIGHT

  Modes     Command	    Meaning
  N,A,E     ATTSET	Set max number of lines used to display attach buffer
  N,A	    BOTSET	Set number of lines used at bottom for page printer
  N,A	    HEIGHT	Set the number of lines used for text display
  N,A	    TOPSET	Set number of lines E skips at top (e.g., for wholine)


The four commands ⊗XTOPSET, ⊗XBOTSET, ⊗XATTSET and ⊗XHEIGHT determine how
E allocates areas on a display terminal's screen.  Each of these commands
sets one display size parameter from the numeric argument to the command,
as follows: (1) if an unsigned argument is given, the parameter is set to
the given value; (2) if a relative argument is given (⊗-⊗# or ⊗+⊗#), then
the corresponding parameter is changed by the given amount; and (3) if the
command is given without any argument, the corresponding parameter is
reset to it default value.  However, the various display size parameters
must fall within certain ranges; any attempt to set a parameter outside
its range will set that parameter to the nearest limit of the range.

The range for a given parameter is generally dependent on the current
settings of the other parameters.  In particular, the ⊗XHEIGHT setting
must be at least two lines bigger than the current ⊗XATTSET value (so that
at least two non-attached lines can be displayed at any time); and since
⊗XTOPSET and ⊗XBOTSET implicitly change the ⊗XHEIGHT setting (see
descriptions below), ⊗XTOPSET and ⊗XBOTSET are limited by the restriction
that the ⊗XHEIGHT area must be at two lines bigger than the current
⊗XATTSET value.

Now here are the commands to set the display size parameters.

  ⊗#⊗XTOPSET    Set the number of lines E skips at the top of the screen
		(e.g., to leave room for the wholine).  Any decrease
		(increase) in the number of lines skipped at the top
		results in a corresponding increase (decrease) in the
		number of lines used to display incore text (see ⊗XHEIGHT
		below).  Thus, ⊗0⊗XTOPSET can be used to make E utilize
		the 2 lines normally left for the wholine.  Whenever the
		number of lines skipped at the top becomes less than two,
		E turns off your wholine to avoid having it overwrite E's
		display, but E remembers that it has turned the wholine
		off and will turn it back on when the top two lines are no
		longer in use (e.g., upon exit, or upon ⊗2⊗XTOPSET).

  ⊗#⊗XBOTSET    Set the number of lines E uses at the bottom of the screen
		for the page printer (where typeout and echo of input go).
		Any decrease (increase) in the number of lines used for
		the page printer results in a corresponding increase
		(decrease) in the number of lines used to display incore
		text (see ⊗XHEIGHT below).  This command is useful, for
		example, when you are debugging some macros that cause
		various things to be typed out which you don't want to go
		quickly off the top of the page printer (use, say,
		⊗9⊗XBOTSET).  This command is also useful for getting one
		more line for incore text display (use ⊗2⊗XBOTSET -- 2 is
		minimum size; however, this may cause some of E's
		occasional information typeout to go off the page printer
		immediately upon being typed out.  The default is 3 lines.

  ⊗#⊗XATTSET    Set the maximum number of lines E will use for displaying
		the attach buffer.  This is useful when you want to
		examine more of the text in the attach buffer than is
		normally displayed, without putting the attach buffer down
		on the page (use, say ⊗∞⊗XATTSET).  This is also useful
		when you have several lines attached, but you don't want
		their display to distract you from the display of the
		normal text on the page (use ⊗1⊗XATTSET, but notice that
		if there is more than one line attached, E will display
		the attach buffer only as one line of ". . ." without even
		a vertical bar to remind you of the attach buffer).  The
		default maximum attach buffer display is 8 lines, and the
		biggest allowed maximum attach buffer display size is 2
		lines smaller than the current incore text display area
		(see ⊗#XHEIGHT below).

  ⊗#⊗XHEIGHT    Set the maximum number of lines E will use for displaying
		incore text (including any attach buffer), not counting
		the header and trailer lines.  This command is sometimes
		useful for reducing the time taken to display a full
		window on a Datamedia (⊗XBOTSET can also be used for that
		purpose), but it can also be useful if part of your
		display's screen doesn't work properly (use this command
		to shrink the size of the area used for incore text, and
		possibly use ⊗XTOPSET to position E's display in the
		working part of your screen); this command can sometimes
		be used to reduce flicker on your III by reducing the size
		of the text display area.  The text display area must be
		at least 2 lines bigger than the current maximum attach
		buffer display size (see ⊗XATTSET above).  The default is
		to display as much text as will fit on your screen.
αβS. ⊗N,⊗O,⊗H: Line, Page & File stacks. ⊗XHOME ⊗XBACKGO ⊗XZFILES ⊗XZPAGES ⊗XZLINES

  Modes     Command	    Meaning
  N,A	    αH	    Go to previous file in file stack (Home)
  N,A	    αβH     Go to Nth previous file, where N is current default arg
  N,A	    ⊗0αH    Type out file stack
  N,A	    ⊗0αβH   Type out default arg for αβH command
  N,A	    ⊗#αH    Go to #th previous file
  N,A	    ⊗#αβH   Go to #th previous file and set default arg to #
  N,A	    ⊗-⊗#⊗H  Go to #th previous file and pop # files off top of stack
  N,A	    ⊗+⊗#⊗H  Re-push # files back onto top of stack and go to new top
  N,A	    αN	    Go to previous line in line stack
  N,A	    αβN     Go to Nth previous line, where N is current default arg
  N,A	    ⊗0αN    Type out line stack
  N,A	    ⊗0αβN   Type out default arg for αβN command
  N,A	    ⊗#αN    Go to #th previous line
  N,A	    ⊗#αβN   Go to #th previous line and set default arg to #
  N,A	    ⊗-⊗#⊗N  Go to #th previous line and pop # lines off top of stack
  N,A	    ⊗+⊗#⊗N  Re-push # lines back onto top of stack and go to new top
  N,A	    αO	    Go to previous page in page stack
  N,A	    αβO     Go to Nth previous page, where N is current default arg
  N,A	    ⊗0αO    Type out page stack
  N,A	    ⊗0αβO   Type out default arg for αβO command
  N,A	    ⊗#αO    Go to #th previous page
  N,A	    ⊗#αβO   Go to #th previous page and set default arg to #
  N,A	    ⊗-⊗#⊗O  Go to #th previous page and pop # pages off top of stack
  N,A	    ⊗+⊗#⊗O  Re-push # pages back onto top of stack and go to new top
  N,E	    αβS     Re-edit the last line edited, at column were activated it
  N,A	    BACKGO	Go back to page that you last came from (see ⊗O cmd)
  N,A	    HOME	Go to relative or absolute page in Home file
  N,A	    ZFILES	Zero (clear) the file stack (and filelist)
  N,A	    ZLINES	Zero (clear) the line stack
  N,A	    ZPAGES	Zero (clear) the page stack


RE-EDITING THE PREVIOUSLY-EDITED LINE: αβS

The αβS command returns you to the last line you edited, if it is still
on the incore page at the place where you edited it.  This command
positions you at the column where you were when you left that line and
can be given from the line editor to take you back to a previously edited
line; thus it can be used to alternate between line editing of two
different incore lines.  Note also that this command is useful if you
left the line editor accidentally.  However, if you left the line editor
with <cr> or α<cr>, then this command will position you at the end of
that line, since it appears to E that that is where you typed the <cr>
(the system places such a <cr> at the end of the line).  Also, line edits
that you flushed with <altmode> cannot be gotten back into with αβS; only
line edits whose final text is accepted by E can be re-entered this way.
Any altering (such as by substitution or justification) of the last line
edited prevents this command from getting back into that line.

The position of the last line edited is updated for all line insertions
and deletions, but if you have since attached the last line edited, then
this command will succeed only if you have put that line back where it
came from (e.g., with αβR).  If you have deleted the last line edited,
then you cannot get into it with this command even if you have undeleted
it and placed it back where it came from.

On non-displays, this command goes back to the last line typed in
(inserted) but of course doesn't edit it.


THE LINE, PAGE, AND FILE STACKS

The commands ⊗N,⊗O,⊗H make use of three corresponding "stacks" of places
you've been at recently: the LINE STACK (⊗N) of lines currently in core,
the PAGE STACK (⊗O) of pages NOT currently in core, and the FILE STACK
(⊗H).  Each of the ⊗N,⊗O,⊗H commands works with the corresponding stack;
all of these commands interpret arguments in the same way and all
distinguish between α<cmd> and αβ<cmd>.  You can return to the #th
previous place, and/or you can "Pop" # places off the stack, and/or you
can "re-Push" # places back on the stack.

The ⊗XBACKGO command is identical with the ⊗O command.

In the descriptions that follow, any sentence referring to "the stack"
should be taken as applying to each of the three stacks.  The word
"place" is used to mean "line", "page", or "file", depending on which
stack is being considered.  The current place is always at the top of
the stack.

The basic forms of these three stack commands are the "single-bucky" (α)
commands αN, αO, and αH, which, respectively, will take you back to the
previous line, page, or file.  If a simple numeric argument ⊗# is added,
then you will go back to the #th previous line, page, or file (e.g.,
⊗3αH will take you to the third previous file).  If you give an argument
greater than the current size of the stack, then you will end up at the
place formerly on the bottom of the stack.

The double-bucky (αβ) forms of these commands (without arguments: αβN,
αβO, and αβH) are just like the single-bucky forms except that the
current default argument for the command is used.  The default arguments
(kept separately for each of the three commands) are all initially 2.
Thus, for example, αβO will initially take you back to the second
previous page.  The default argument for a double-bucky command is
changed by typing the double-bucky command with the desired future
default.  Note that this both sets the default argument and executes it!
For example, ⊗5αβH takes you to the fifth previous file and sets the
default arg for subsequent αβH commands to 5.

Note that with the default argument set to some number J, repeated use
of the double-bucky command with no argument will cause you to loop
through J+1 places.  Thus when you are working on J+1 pages (or lines
or files) which you want to loop through, it is useful to set the
default arg to J.

You can find out what is on any of the stacks or what the default arg is
for any of the double-bucky commands by using an argument of zero (⊗0).
A zero arg with a double-bucky command types out the default arg for the
double-bucky command.  A zero arg with a single-bucky command types out
the corresponding stack, including the current place (which is at the
top of the stack).  Thus ⊗0αN types out the line stack and ⊗0αβO types
out the default arg for the αβO command (without executing it).  The
⊗0αH command also types the stack level of each file so that you know
what argument to give the αH command to get to any file listed.

Since the lists of recently visited places have been called stacks,
there must be some stack adjusting operations -- and there are.  Except
when one of the below stack adjusting operations has been used, the
"stack" is really an ordered list of the most recently visited DISTINCT
places.  The list is ordered by the recentness of your being at each
place, and the places are kept distinct by removing from the middle of
the stack any entry for the place you are currently at.  The current
place is always the top entry in the stack.

The STACK ADJUSTING OPERATIONS all involve a RELATIVE argument being
given to one of the ⊗N,⊗O,⊗H commands.  There are two possibilities:
the relative argument can be negative (⊗-⊗3) or positive (e.g., ⊗+⊗4)
(note that ⊗5 is not a relative argument).  Negative arguments cause
"Popping" of places off the stack and positive arguments cause
"re-Pushing" of places back on the stack.  The default value for a
relative arg is one (i.e., ⊗+⊗N means ⊗+⊗1⊗N, and ⊗-⊗O means ⊗-⊗1⊗O).
You cannot pop or re-push more places than there are on the stack.

A NEGATIVE RELATIVE argument causes the given number of places to be
"Popped" off the top of the stack and the user is moved to the new top
of the stack.  This is useful if, having gotten somewhere, you decide
you're not interested in remembering that place on the stack and you
want to go back to some previous place.  For example, ⊗-⊗N (default
number is 1) will take you back to the previously remembered line and
not leave an entry for the current line just one below the new top of
the stack (as αN would).  Actually, when you "pop" a place off the
stack, it is remembered (for the "re-push" command) by putting it on the
bottom of the stack.

A POSITIVE RELATIVE argument (e.g., ⊗+⊗4) causes the given number of
places to be "re-Pushed" onto the top of the stack from the bottom of
the stack and you are then moved to the new top of the stack.  This is
mainly useful if you have just popped one or more places off the stack
and then decide you want another look at such a place.  For example, if
you do a ⊗-⊗N, then doing a ⊗+⊗N immediately will undo the ⊗-⊗N
(including both returning you to a particular line and restoring the
stack to its previous state).  Of course, if you haven't popped anything
off the top of the stack, then what gets pushed onto the top isn't
really "re"pushed after all, but is just whatever happened to be sitting
at the bottom of the stack.


Now for some details pertaining to particular stacks.


The line stack:

The line stack only remembers lines that are more than four (4) lines
away from each other.  (Remember, the current line is the top of the
stack.)  Thus moving down the page by ⊗> does not leave a trail of
remembered places, but in fact flushes from the middle of the line stack
the entries for any lines that are approached (within four lines).

When you go to a different page (not already in core), your line stack
is lost irretrievably.  It is not restored when you return to a
previous page.

Entries in the line stack are corrected for line insertions and
deletions, including those resulting from the attach and justification
commands.  The ⊗XCANCEL command preserves the current line stack without
attempting to un-correct entries for lines previously inserted or
deleted, but it flushes entries for lines that no longer exist (i.e.,
are beyond the new last line in core).

Multiple consecutive FF and VT (and ⊗W) commands do NOT remember (on the
line stack) intermediate stopping places.  But ANY command besides FF,
VT, ⊗W, and ⊗0⊗N will cause the current line to get remembered.  While
you are FF/VTing around a page, the αN command will take you back where
you started the current string of FF/VT commands (even if you are
already there!) and will remember, of course, the line you are leaving.

With each line in the line stack, E remembers the window position that
existed when you left that line.  When you return to a line via ⊗N, the
old window position associated with that line is restored unless the line
was already on the screen, in which case the window is not changed.


The page stack:

Each entry in the page stack contains not only a page number, but also
the line number and window you were at when you left that page.  The
⊗O command restores this line number and window.

When you return to a previous file (whether by number or by explicit
filename), the top part of your page stack from that file is restored
along with all line marks from that file.

If you ⊗XAPPEND to the current incore page(s) a page that was remembered
on the page stack, its entry in the stack is flushed since the page is
now in core.


The file stack:

Whenever you return to a previous file with one of the ⊗H, ⊗ε, ⊗λ and ⊗?
commands, the file is opened in the mode that you were in when you left it
(e.g., /N), and at the page and line where you were when you left it.  The
window position is also restored.  Whenever you return with the ⊗H
command, your Readonly/Readwrite mode is restored to its previous state
for that file.  If you return to a previous file by using the ⊗ε or ⊗λ
command without an arg (and typing the filename explicitly), you can
override the default starting page and line with switches.

The E manual (this file) is never remembered in the file stack if you
get to it via the ⊗? command or the ? filename.  Thus when you say ⊗?,
the first subsequent αH command will take you back to the file you
previously were in and a second αH will take you back, not to E.ALS,
but to the second previous file you were in prior to entering E.ALS.


The (⊗+ or ⊗-) ⊗#⊗XHOME command:

You can get back to the previous file in the stack AND AT THE SAME TIME
TO A SPECIFIC ABSOLUTE OR RELATIVE PAGE by using the ⊗XHOME command.  An
absolute argument will position you to that page as you return to the
file, and a relative argument will position you that many pages from the
page where you would have otherwise returned.  Thus ⊗4⊗XHOME will return
you to the previous file on page 4.


CLEARING THE STACKS:

The extended commands ZFILES, ZPAGES and ZLINES clear the file, page
and line stacks respectively.

    ⊗X ZFILES        Zero (clear) the file stack.
    ⊗X ZPAGES        Zero (clear) the page stack.
    ⊗X ZLINES        Zero (clear) the line stack.

Undeleting lines of text: ⊗XUNDELETE

  Modes     Command	    Meaning
  N,A	    UNDELETE	Restore recently deleted or changed text


	Deleted lines are saved (up to a certain limit) in the delete
stack and can be undeleted with the ⊗XUNDELETE command.  Virtually every
time one or more lines of incore text are changed, the previous versions
of the changed lines are preserved in the delete stack.  Thus the delete
stack includes not only lines that have been explicitly deleted, but also
lines that have been changed with the line editor, with a substitution
command, with a justification command, etc.  Only the ⊗XCANCEL command
does away with incore text without the ability to retrieve it (if you
explicitly want to save some text over a ⊗XCANCEL command, you can either
attach that text or explicitly delete it for undeleting later).

	The limit of deleted lines saved is indicated by a (settable)
maximum number of deleted characters; this limit is initially 5000
characters (approximately 1K of core).  However, this limit is allowed to
be surpassed by a single command that itself deletes more than the current
limit of deleted characters.  Thus the text deleting of any command
(except ⊗XCANCEL, which doesn't save in the delete stack the text being
cancelled) can be undone immediately, provided that no other command that
deletes lines is executed first.  And, of course, even if another deleting
command is executed, the earlier deleted lines can still be undeleted if
the maximum character count for deleted lines is not exceeded.  Lines are
undeleted in the opposite order from their deletion; that is, deleted
lines go into a stack.  When the maximum deleted character count is caused
to be exceeded by a newly deleted line, one or more of the oldest deleted
lines (on the bottom of the stack) are flushed (forever) until the
character count is brought back within the limit, but lines deleted by the
current command are never flushed until another command deletes some more
lines.

	When text is undeleted, the undeleted lines are removed from the
delete stack and inserted at the beginning of the attach buffer (even if
no lines were previous attached).  (Note therefore that an undeleted line
cannot be undeleted again (unless it is re-deleted first)).  Now here are
the descriptions of the various forms of the ⊗XUNDELETE command.

	⊗XUNDELETE      Undeletes (into the attach buffer) the last group
			of lines that was deleted by a single command,
			unless those lines have already been undeleted, in
			which case this command (with no argument) won't
			do anything (but complain).
	⊗#⊗XUNDELETE	Undeletes # lines (into the attach buffer).
	⊗0⊗XUNDELETE    Tells how many lines and characters can currently
			be undeleted, and it will also tell what the
			current deleted character limit is.
	⊗-⊗#⊗XUNDELETE  Sets the deleted character limit to # characters
			(note the negative argument).
Lisp code indenting commands: α/ αβ/ ⊗XLISPSYNTAX

  Modes     Command	    Meaning
  N,E	    α/	    Lisp-indent current line by context above it
  N,E	    αβ/     Lisp-indent next line by context above it
  N,E	    ⊗#α/    Lisp-indent # lines from arrow by context above
  N,E	    ⊗#αβ/   Lisp-indent # lines from next by context above
  A	    α/	    Lisp-indent first attached line (no-op!)
  A	    αβ/     Lisp-indent first attached line in context of page
  A	    ⊗#α/    Lisp-indent first # attached lines
  A	    ⊗#αβ/   Lisp-indent first # attached lines in context of page
  N,A,E     LISPSYNTAX	Examine and/or modify char interpretation by ⊗/ cmd


	The α/ and αβ/ commands parse Lisp S-expressions and indent lines
accordingly (with tabs and spaces as needed).  Text is never moved from
one line to another; only the indentation of each line is subject to
change.  The ⊗#α/ command indents # lines (default is one line) starting
at the current line.  Except in attach mode (see below), the ⊗#αβ/ does
the same thing as ⊗#α/ but first moves down a line (keeping you in line
insert mode if you are already in it).  Both α/ and αβ/ without an arg
indent one line and leave you in the line editor positioned just after the
indentation (αβ/ moves down a line first, of course).  When an explicit
arg is given, neither command leaves you in the line editor.  All forms of
⊗/ can be given from within the line editor.

	The ⊗/ command recognizes "super-brackets".  This makes ] in the
text equivalent to enough )'s to close back to the matching [, or to close
all hanging ('s if no hanging [ is present to match.

	The indentation set up is determined by examining the S-expression
which starts at or just before the current line, where that S-expression
is defined to begin at the nearest line that starts with either a left
parenthesis or a left square bracket (or their equivalents), or at the
beginning of the current page if no initial left parenthesis or left
bracket is found.  However, the current line is not so checked for the
beginning of an S-expression when the command is given without an argument
nor when the command is given while in attach mode.

	In attach mode, the α/ command does not look for any context
before the first line of the attach buffer, but the αβ/ command looks back
into the normal page text just ahead of the attach buffer to allow you to
indent the attach buffer while positioned at the proper place on the page.

	A negative argument to either command means to indent the given
number of lines before the current line (without ever moving down a line);
in attach mode a negative argument makes the command a no-op.

	The parsing of S-expressions is by MacLisp character set
interpretation, but the command ⊗XLISPSYNTAX described below allows
different character interpretations.  For more details, see GLS.


MODIFYING LISP CHARACTER INTERPRETATIONS: ⊗XLISPSYNTAX

	The command ⊗XLISPSYNTAX can be used to examine and/or modify the
syntax table which drives the ⊗/ (LISP indentation) command.  This table
has one entry for each of the 128 (200 octal) characters.  Each entry
consists of one or two characters which describe a LISP character syntax
category.  The second (or only) character is a mnemonic for the role
played in the syntax of LISP S-expressions.  The first character of two is
an auxiliary character used for certain kinds of matching, e.g. of string
quotes or super- brackets.  The syntax types are:

  TYPE	NAME		AUX?	CHARACTERS WHICH INITIALLY HAVE THAT SYNTAX
   (	left paren	no	(
   )    right paren	no	)
   [    left super	no	[
   ]    right super	yes	]
   /    char quoter	no	/ %
   '    quote macro	no	` ' ,
   |    string quoter	yes	| "
   ↔    carriage return	no	CR
   ;    semicolon	yes	;
    	space		no	NULL TAB LF VT FORM SPACE BS
   A    letter		no	all others (e.g. A-Z a-z 0-9 + - * @ # ...)

(This initial arrangement represents a compromise between MacLISP and
InterLISP syntax.  In MacLISP, there are no superbrackets, and only /
(and not %) is a character quoter.  In InterLISP, only % (and not /)
is a character quoter; | does not serve as a string-like atom delimiter;
and semicolon is not a comment character.)

	The auxiliary character is used for only a few special cases.
For a right superbracket, it is the character which is the matching
left superbracket.  (Thus one can have several independent pairs of
superbrackets, in principle.  This may not square with InterLISP
superbracket semantics, however.)  For a comment character, it is the
character which terminates the comment.  For a string quoter it is the
character which terminates the string (normally the same one which
begins it, but this extra flexibility is provided anyway).

The syntax table can be modified using the command:

	⊗XLISPSYNTAX<space><octal of char to be affected><space>
		<optional auxiliary char in octal, followed by space>
		<representative mnemonic syntax char><CR>

Examples: to make < and > be parentheses, one would do:
	⊗XLISPSYNTAX 74 (
	⊗XLISPSYNTAX 76 )
To make % not be a character quoter, but only a letter:
	⊗XLISPSYNTAX 45 A
To make ⊂ and ⊃ be superbrackets, one would say:
	⊗XLISPSYNTAX 20 [
	⊗XLISPSYNTAX 21 20 ]
The extra "20 " in the second one is needed to specify that ⊃ is
matched by ⊂.  However, the first command is also needed explicitly
to define ⊂ as a left superbracket.

The command
	⊗-⊗XLISPSYNTAX<CR>
resets all the interpretations to their initial default.

Finally, the command
	⊗XLISPSYNTAX<space><octal of char><CR>
will merely cause E to type out the current interpretation of the char
given in octal.

In Terse mode (see ⊗XTERSE command), the typeout resulting from the
⊗XLISPSYNTAX command is suppressed except in the last case shown (which
is an explicit request for this typeout).